home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
C/C++ Users Group Library 1996 July
/
C-C++ Users Group Library July 1996.iso
/
vol_400
/
433_01
/
svgacc21.txt
< prev
next >
Wrap
Text File
|
1994-05-08
|
300KB
|
12,926 lines
REFERENCE MANUAL
FOR SVGACC
THE SUPER VGA
GRAPHICS LIBRARY
FOR USE WITH
MICROSOFT
AND BORLAND
C/C++
1993-1994 by Zephyr Software - Stephen L. Balkum and Daniel
A. Sill
All rights reserved. No part of this book shall be reproduced
or transmitted by any means, electronic, mechanical,
photocopying, recording or otherwise, without written
permission from Zephyr Software - Stephen L. Balkum and Daniel
A. Sill.
Although every effort has been made to insure the accuracy of
the material in this book, Zephyr Software, Stephen L. Balkum
and Daniel A. Sill assume no responsibility for errors or
omissions. In addition no liability is assumed for damages
resulting from the use of the information contained herein.
Printed in the United States of America
Trademarks
The Graphics Interchange Format (c) is the Copyright property
of CompuServe Incorporated.
GIF (sm) is a Service Mark property of CompuServe
Incorporated.
Sound Blaster and Sound Blaster Pro are trademarks of Creative
Labs, Inc.
All others are trademarks of their respective owners.
ii
SOFTWARE LICENSE AGREEMENT
By using this software, you agree to the terms of
this agreement.
No warranties are expressed or implied. In no event
shall Zephyr Software, Stephen L. Balkum or Daniel
A. Sill be held liable for damages resulting from
the use or misuse of this product, including but not
limited to implied warranties of fitness for a
particular purpose.
The shareware version may be freely distributed as
long as all files stay together and are not modified
in any way. No cost may be charged for the
shareware version beyond normal and reasonable
copying and distribution expenses.
No products developed with this software shall be
sold unless this software has been registered with
Zephyr Software, Stephen L. Balkum or Daniel A.
Sill.
At no time for any reason shall this software be
reverse engineered, decompiled or disassembled.
This software may not be rented or leased.
This software may be used only on one terminal or
one computer at any one given moment in time. This
software may not be installed on a network of any
type. Contact Zephyr Software, Stephen L. Balkum or
Daniel A. Sill for networking options.
United States Government Restricted Rights:
Use, duplication or disclosure of this software and
documentation by the U.S. Government is subject to
the restrictions as set forth in subparagraph
(c)(1)(ii) of the Rights in Technical Data and
Computer Software clause at DFARS 252.227-7013.
Contractor/manufacturer is Stephen L. Balkum and
Daniel A. Sill, P.O. Box 7704, Austin, Texas 78713-
7704.
The ownership of this software may be transferred as
long as Zephyr Software, Stephen L. Balkum or Daniel
A. Sill is notified in writing of the transfer date
and new owner. The new owner must agree to this
contract. The transfer must include all registered
updates and previously registered versions. The
original owner may not retain any copies in any form
of the registered software or its documents.
iii
INTRODUCTION
We spent weeks searching the depths of the internet ftp sites
for a library that would allow the programmer full access to
the abilities of Super VGA. We wanted the colors VGA could
provide and better resolution than EGA could provide.
Professionally developed libraries with this ability were
definitely out of our price range. After our searches
continuously returned nothing, we decided to fill the apparent
void in the shareware market.
Our searches did give two useful packages: John Bridges'
VGAKIT and Finn Thoegersen's VGADOC. We began with these two
works and developed a graphics library intended to allow the
programmer access to the huge world of high resolution
programming.
On the surface the task appeared quite simple. However, it
quickly became obvious that the routines in this library would
be required to affect extremely large amounts of data.
Operations must be quick to be successful. Therefore, every
effort was made to create the fastest code possible - even at
the expense of size. For this reason we opted to write code
with the 32 bit instructions of the 80386 and 80486 chips. It
is our opinion that anyone with a hi-res card in a lesser
machine may have some priorities out of order. All routines
are written in assembly and use absolutely no floating point
values. Anytime a real number was required, fixed point
notation was used. In addition we attempted to write the
routines such that any reasonable argument passed can be
interpreted intelligently by the library.
With the numerous Super VGA cards available and no well
established standard we chose John Bridges' identification and
bank switching routines as a beginning. These two routines
have undergone some modification, but not enough to justify
copyrighting this portion of the library's code by Zephyr
Software. We have no intentions of releasing our changes to
these routines into the public domain. From that point onward
all code is original. In some instances common algorithms
were researched and original code written according to that
algorithm.
This Super VGA library gives the programmer transparent access
to twenty different Super VGA cards. These cards include
Acumos, Ahead, ATI Technologies, Avance, Chips and
Technologies, Cirrus Logic, Everex, Genoa, MXIC, NCR, Oak
Technologies, Paradise/Western Digital, Primus, Realtek,
Trident, Tseng Labs, Video 7 and the VESA standard. Please
see the WHICHVGA function for the specific chipsets. The
programmer only needs to verify that the end user's card has
been identified, but not which card was recognized. After
proper identification, all functions react in exactly the same
fashion. The library contains functions to draw all of the
2
major primitives. In addition there are functions that modify
the screen palette, write text on the screen with a choice of
fonts and modify the reaction of the primitives.
Identification routines include not only the video card, but
also the amount of video memory, type of processor and
installed pointing devices. Advanced functions provide full
mouse support (when used with a Microsoft compatible driver)
and joystick support. Finally, support for two dimensional
and three dimensional coordinate systems is provided including
rotation, translation, scaling and projection.
3
SUGGESTED METHODS FOR USING THIS LIBRARY
VERIFICATION OF A COMPUTER'S HARDWARE
It is strongly recommended that any program written with this
library first verifies that the computer is a 80386 or better
by calling the WHICHCPU function. Many of the library's
functions use 386 exclusive code which may cause a computer
with a lesser processor to crash. In addition WHICHMOUSE must
be called before calling any of the mouse functions. Lastly,
it is recommended that WHICHJOYSTICK be called before a
program uses the joystick routines.
It is required that a program call WHICHVGA prior to any
function that communicates with the video card. If WHICHVGA
returns a zero for unknown card type, the program should not
call any graphics function. Without proper identification of
the video card any graphics function will likely cause a
system failure. It is recommended, although not necessary,
that a program call WHICHMEM prior to calling any RES
function. Although the video card was properly identified, it
may not have sufficient onboard memory to support the desired
resolution. As a second check the RES functions will do
nothing if the video card has not been identified or if the
video card does not support the specified resolution for
memory or hardware reasons.
THE 256 COLOR PALETTE
The 256 color palette of the Super VGA cards is a six bit
palette. Each of the 256 colors of the palette are described
by three values representing the intensity of the colors red,
blue and green. These values can range from 0 to 63. Anytime
a value outside of this range is used, the video card simply
ignores the upper two bits. Therefore, 64 is the same as 0.
This should be taken into consideration when manipulating the
palette or when importing a palette from an external source
such as a GIF image.
USE OF 2-D AND 3-D FUNCTIONS
In the interest of speed, the 2-D and 3-D functions were
written to best work on multiple points at once. We refer to
these functions as object-oriented. This means that the
points defining an object (a box, a house, etc.) should be
contained within one array or part of an array and calls to
the functions should act on all of the points in the array.
Calls to functions have a high speed overhead, therefore,
placing more than one object in the same array and passing the
entire array to the functions can be beneficial. However,
these functions will work on a single point as well.
A consequence of our object-oriented 2-D and 3-D functions is
the use of the scaling functions. When scaling objects, we
4
recommend the object be defined about the origin. D2SCALE and
D3SCALE both work with respect to the origin. This eliminates
a significant number of translations that would otherwise be
required by having a definable scale origin. For example, to
draw two boxes, one scaled by one-half of the other, each
rotated by 45 degrees at the center of the screen, the
recommended procedure is as follows:
define an array BOX containing the 2-D points: (100, 100),
(-100, 100), (-100, -100), (100, -100), (note: the box is
centered about the origin.)
rotate BOX by 45 degrees about (0, 0) and place the output
in RBOX,
scale RBOX by 50% (scaling factor would be 128, or 80 hex)
and place output in SRBOX,
translate RBOX to the center of the screen - a translation
of 320, 240 in 640x480 resolution - and place output in
TRBOX,
translate SRBOX to the center of the screen - same
translation as for RBOX - and place output in TSRBOX,
draw TRBOX and TSRBOX on the screen.
Notice that by defining the box centered about the origin the
translation values were extremely intuitive. Also notice that
if we had scaled the second box after the translation, it
would have been draw in the upper left quadrant of the screen
instead of the center.
In mathematics and many sciences it is customary that in a 2-D
coordinate system the Y axis increases upward and the X axis
increases to the right. The computer industry has decided the
Y axis should increase downward. The 2-D functions are not
affected by the choice in coordinate systems. However, it is
important to remember that a positive rotation in D2ROTATE
rotates from the positive X axis to the positive Y axis.
Therefore, when using mathematical conventions, a positive
rotation moves counter-clockwise. On the computer screen a
positive rotation moves clockwise.
The 3-D coordinate system follows mathematical conventions by
using a right-handed coordinate system. The easiest way to
visualize this coordinate system is by using your right hand.
Place your index finger and thumb at a right angle to one
another as if to form an imaginary pistol. Now place your
second finger at a right angle to your index finger. It
should be at a right angle to your thumb as well. This
represents the three axes. The index finger is the X axis,
the second finger is the Y axis and the thumb is the Z axis.
The easiest way to remember rotation directions in this system
is cyclically. A positive rotation about the X axis rotates
the Y axis into the Z axis. A positive rotation about the Y
axis rotates the Z axis into the X axis. A positive rotation
about the Z axis rotates the X axis into the Y axis.
5
After doing all necessary 3-D transformations, projection onto
the 2-D computer screen is required. Although the computer
screen's coordinate system does not follow mathematical
conventions, the D3PROJECT function automatically takes care
of all conversions. The programmer only needs to draw the
resulting object on the screen with FILLCONVEXPOLY or a series
of DRWLINEs.
THE CONCEPT OF SPRITE GRAPHICS
The key to sprite graphics is the assumption that only a small
percentage of the pixels in a graphics block are used by the
animation and the remaining pixels should be treated as
transparent, revealing the background behind the sprite. The
sprite routines in this library only act on non-transparent
colors, thus, saving time by ignoring a large number of
pixels. When retrieving the background for a sprite, prior
knowledge of the sprite itself permits obtaining background
only where it is necessary.
The following steps outline an example of the recommended
procedure for using the sprite functions:
1.draw the sprite on the screen - a white stick figure on a
black background, for example
2.use BLKGET to place the sprite in an array STICK
3.use SPRITEGAP to simultaneously retrieve the background
into BACKSTICK and place STICK on the screen, declaring
black as the transparent color
4.use SPRITEPUT to replace the background BACKSTICK in the
same location as step 3
5.repeat steps 3 and 4 as many times and in as many
locations as desired
GLOBAL VARIABLES
Access to several global variables provided to the programmer.
The most important two variables are MAXX and MAXY. These two
values give the current resolution and are set by the RES###
functions. They should not be changed directly at any time by
the programmer. Doing so may cause erratic results from many
of the graphics functions in this library. These variables
initially contain 0.
Four other variables, VIEWX1, VIEWY1, VIEWX2, VIEWY2, can be
accessed by the programmer. They define the current viewport
used for clipping purposes. These values, also, should not be
changed directly by the programmer. The SETVIEW function
should be used to change these values as it performs important
error checking. The viewport is defined as the whole screen
by the RES### functions. If drawing on more or less than the
entire screen is desired, call SETVIEW as necessary.
6
EXTENDED MEMORY SUPPORT
With the higher screen resolutions, more memory may be needed
for data storage. For this reason extended memory support is
provided. Accessing extended memory requires the computer to
switch into protected mode. The process of switching into
protected mode and returning is handled by the extended memory
manager, usually HIMEM.SYS. The switch is relatively slow.
Therefore, it should be used as fast storage access since it
is much faster than disk access.
Extended memory access is also limited by the number of
available handles. The limit is controlled by a switch on the
extended memory manager's command line and normally defaults
to 32. Also, it is imperative that all allocated extended
memory blocks be freed before the program terminates. Unfreed
memory blocks will be unavailable until the computer is
rebooted.
CONVENTIONS USED IN THIS MANUAL
All parameters, other than pointers, passed to and from
functions and procedures in this graphics library are short
(two byte) integers A byte variable type is assumed to be an
unsigned character. No floating point values are used. By
not using real numbers round-off error can be a concern.
Under most circumstances this error will not be a problem and
will not be noticed. The use of large numbers in rotations is
recommended.
No functions in this library allocate memory for the
programmer, except, of course, XMSALLOCATE. It is the
programmer's responsibility to be sure all pointers reference
properly allocated memory of the appropriate size.
Whenever a pixel is written on the screen, a mode is required.
Unless otherwise noted, there are five possible modes:
NO_ACTION, SET, XOR, OR and AND. These modes are represented
by the numbers zero through four respectively. NO_ACTION is
self-explanatory. Technically, SET is the fastest mode.
However, XOR maybe the most useful. XOR'ing a point twice
with the same color returns the original color. This can be
used to cover and uncover graphics. In addition when a
reference to a color index is made, only values between and
including 0 and 255 are valid. Any integer will work, but
only the lowest eight bits are recognized.
7
BLKGET
PROTOTYPE
extern int far blkget (int x1, int y1, int x2, int y2,
RasterBlock far *gfxblk)
INPUT
X1, Y1 - top left corner of block
x2, y2 - bottom right corner of block
OUTPUT
BLKGET returns 1 if successful, 0 if failed.
gfxblk - retrieved bitmap
USAGE
BLKGET stores the pixel data contained within the block
defined by (X1, Y1)-(X2, Y2) in the variable referenced by
gfxblk. Memory for gfxblk must be allocated as a
RasterBlock structure with a data size in bytes equal to
[(X2-X1+1)*(Y2-Y1+1)]
plus four bytes for the width and height integers of the
RasterBlock structure.
Note, however, that gfxblk can be quite large. If the size
of gfxblk is insufficient, BLKGET will overwrite any data in
memory contained beyond gfxblk and may possibly cause the
system to crash. BLKGET enforces X2X1 and Y2 Y1. Also,
the coordinates must be valid on the screen at the current
resolution.
SEE ALSO
BLKPUT, BLKRESIZE, BLKROTATE, GETLASTSTRING, SPRITEGAP,
SPRITEGET, SPRITEPUT
EXAMPLE
/*
* Places 1/4 of a circle at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int a,b,c,d;
8
RasterBlock *blkdata;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwcircle(1,10,30,30,20);
fillarea(30,30,10,7);
a = b = 0;
c = d = 30;
blkdata = (RasterBlock *)malloc((c-a+1)*(d-b+1)+4);
blkget(a,b,c,d,blkdata);
blkput(1,320,240,blkdata);
getch();
videomodeset(vmode);
exit(0);
}
9
BLKPUT
PROTOTYPE
extern void far blkput (PixelMode mode, int x, int y,
RasterBlock far *gfxblk)
INPUT
mode - pixel write mode
x, y - location for top left corner of block
gfxblk - RasterBlock pointer to bitmap
OUTPUT
no value returned
USAGE
BLKPUT places the pixel data contained in the variable
referenced by gfxblk on the screen. The top, left corner of
the block is specified by (X, Y). Any (X, Y) is acceptable
and any portion of the block that lies outside of the
currently defined viewport will not be drawn.
SEE ALSO
BLKGET, BLKRESIZE, BLKROTATE, GETLASTSTRING, SPRITEGAP,
SPRITEGET, SPRITEPUT, GIFPUT, SETVIEW
EXAMPLE
See BLKGET
10
BLKRESIZE
PROTOTYPE
extern void far blkresize (unsigned newxsize, unsigned
newysize, RasterBlock far *sourcegfxblk, RasterBlock far
*destgfxblk)
INPUT
newxsize, newysize - size of resulting bitmap in destgfxblk
sourcegfxblk - RasterBlock pointer to source bitmap
OUTPUT
no value returned
destgfxblk - resized bitmap
USAGE
BLKRESIZE takes the bitmap in sourcegfxblk and scales it up
or down according the to values passed in newxsize and
newysize. The resulting bitmap is returned in destgfxblk
which should already be declared with a size calculated
according to the equation in BLKGET. Neither newxsize nor
newysize should be zero.
SEE ALSO
BLKGET, BLKPUT, BLKROTATE
EXAMPLE
/*
* Show blkresize
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
#define randnum(size) (rand() % (int)(size))
void main(void)
{
int vmode, i, j, colr, x1, y1, x2, y2;
RasterBlock *gfxblk1, *gfxblk2;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !res640() )
exit(1);
i=20000;
gfxblk1 = (RasterBlock *)malloc(i);
11
if (!gfxblk1) {
restext();
printf("ERROR: Allocating memory for gfxblk1: %d
bytes\n",i);
exit(1);
}
gfxblk2 = (RasterBlock *)malloc(i);
if (!gfxblk2) {
restext();
printf("ERROR: Allocating memory for gfxblk2: %d
bytes\n",i);
exit(1);
}
for(i=0;i<=25;i++) {
x1 = randnum(50);
y1 = randnum(50);
x2 = randnum(50);
y2 = randnum(50);
colr = randnum(16);
drwline(1,colr,x1,y1,x2,y2);
}
x1 = 0;
y1 = 0;
x2 = 50;
y2 = 50;
drwbox(1,15,x1,y1,x2,y2);
blkget(x1,y1,x2,y2,gfxblk1);
x1 = maxx / 2;
y1 = maxy / 2;
blkresize(50,50,gfxblk1,gfxblk2);
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
for(i=x2;i<=x2+50;i++) {
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
blkresize(i,i,gfxblk1,gfxblk2);
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
sdelay(3);
}
for(i=x2+50;i>=x2-50;i--) {
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
blkresize(i,i,gfxblk1,gfxblk2);
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
sdelay(3);
}
for(i=x2-50;i<=x2+1;i++) {
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
blkresize(i,i,gfxblk1,gfxblk2);
blkput(2,x1-(gfxblk2->width)/2,y1-(gfxblk2-
>height)/2,gfxblk2);
12
sdelay(3);
}
getch();
videomodeset(vmode);
exit(0);
}
13
BLKROTATE
PROTOTYPE
extern int far blkrotate (int ang, int backfill,
RasterBlock far *sourcegfxblk, RasterBlock far *destgfxblk)
INPUT
ang - integer degree to rotate source bitmap
backfill - index to color in current palette to fill blank
space in destgfxblk
sourcegfxblk - RasterBlock pointer to source bitmap
OUTPUT
BLKROTATE returns 1 if successful, 0 if unsuccessful.
destgfxblk - rotated bitmap
USAGE
BLKROTATE takes the bitmap in sourcegfxblk and rotates by
the number of degrees specified in ang. The bitmap rotation
algorithm is a three-pass shear technique modified to make
efficient use of this library's internal buffers. Blank
space around the newly rotated block is filled with the
color given by backfill. The resulting bitmap is stored in
destgfxblk. The size of destgfxblk should be at least as
big as given by BLKROTATESIZE.
The function will fail if it calculates that the internal
buffers would be overflowed or if the destination array
would be larger than 65536 bytes. BLKROTATESIZE should be
called first to ensure that buffer integrity is maintained.
SEE ALSO
BLKGET, BLKPUT, BLKRESIZE, BLKROTATESIZE
EXAMPLE
/*
* Show blkrotate
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int xinc, yinc, x1, y1, x2, y2, i, j, colr, vmode, cntx,
cnty, rot;
RasterBlock *gfxblk, *gfxblk2, *spritebkgnd;
14
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !res640() )
exit(1);
xinc = maxx/10;
yinc = maxy/20;
x1 = maxx/2-xinc;
y1 = maxy/2-yinc;
x2 = maxx/2+xinc;
y2 = maxy/2+yinc;
i = (x2-x1+1)*(y2-y1+1)+4;
gfxblk = (RasterBlock *)malloc(i);
if (!gfxblk) {
restext();
printf("ERROR: Allocating memory for gfxblk: %d
bytes\n",i);
exit(1);
}
colr = 1;
for(i=0;i<=maxx/2;i++) {
drwcircle(1,colr,maxx/4+i,maxy/2,maxy/5);
colr+=1;
if(colr>15)
colr = 1;
}
drwbox(1,0,x1,y1,x2,y2);
blkget(x1,y1,x2,y2,gfxblk);
cntx = (x2-x1) / 2 + x1;
cnty = (y2-y1) / 2 + y1;
fillarea(x1+2,y1+2,0,0);
i = blkrotatesize(45,gfxblk);
if ( !i ) {
restext();
printf("ERROR: rotated sprite will be to large");
exit(1);
}
spritebkgnd = (RasterBlock *)malloc(i);
if (!spritebkgnd) {
restext();
printf("ERROR: Allocating memory for spritebkgnd: %d
bytes\n",i);
exit(1);
}
gfxblk2 = (RasterBlock *)malloc(i);
if (!gfxblk2) {
restext();
printf("ERROR: Allocating memory for gfxblk2: %d
bytes\n",i);
exit(1);
}
blkget(x1,y1,x2,y2,spritebkgnd);
setview(0,64,maxx,maxy);
15
for(i=0;i<=360;i+=3) {
rot = blkrotate(i,1,gfxblk,gfxblk2);
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
spritegap(1,cntx-(gfxblk2->width)/2,cnty-(gfxblk2-
>height)/2,gfxblk2,spritebkgnd);
sdelay(3);
}
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
blkput(SET,x1,y1,(RasterBlock *)gfxblk);
videomodeset(vmode);
exit(0);
}
16
BLKROTATESIZE
PROTOTYPE
extern int far blkrotatesize (int ang, RasterBlock far
*sourcegfxblk)
INPUT
ang - integer degree to rotate source bitmap
sourcegfxblk - RasterBlock pointer to source bitmap
OUTPUT
BLKROTATESIZE returns the number of bytes needed for the
destination array if successful, 0 if unsuccessful.
USAGE
BLKROTATESIZE takes the bitmap in sourcegfxblk and
calculates the required size of the output buffer needed
when BLKROTATE is called. It also insures that the internal
library buffers are not overflowed. The function will fail
if it calculates that the internal buffers would be
overflowed or if the destination buffer would be larger than
65536 bytes. BLKROTATESIZE should be called prior to
BLKROTATE to insure that buffer integrity is maintained.
SEE ALSO
BLKGET, BLKPUT, BLKRESIZE, BLKROTATE
EXAMPLE
See BLKROTATE
17
BYTECOPY
PROTOTYPE
extern void far bytecopy (void far *src, void far *dst, long
numbytes)
INPUT
src - pointer to array to be copied
numbytes - number of bytes to copy from src (<65536)
OUTPUT
no value returned
dst - copy of array
USAGE
BYTECOPY copies the specified number of bytes from src to
dst. It assumes that space for dst has been properly
allocated. It is much faster than using a FOR loop or
MEMCPY.
SEE ALSO
PALCOPY
EXAMPLE
/*
* show byte copy
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int i;
int test1[10], test2[10];
for(i=0;i<10;i++)
{
test1[i] = i;
}
bytecopy(test1,test2,sizeof(test1));
printf("ok...we initialized one array with data, copied
that\n");
printf("array to an a new array...here are the
results:\n");
printf(" \n");
printf("source array destination array\n");
for(i=0;i<10;i++)
18
{
printf(" %d
%d\n",test1[i],test2[i]);
}
exit(0);
}
19
D2ROTATE
PROTOTYPE
extern void far d2rotate (int points, int xorigin, int
yorigin, int ang, D2Point far *inary, D2Point far *outary)
INPUT
numpoints - number of points to be rotated
xorigin, yorigin - center of rotation
angle - angle of rotation about center
inary - D2Point pointer to array containing points to rotate
OUTPUT
no value returned
outary - D2Point array of rotated values
USAGE
D2ROTATE takes the two dimensional points given in inary and
rotates them by the specified angle about xorigin, yorigin.
The results are returned in outary which can be the same as
inary. A positive angle causes a clockwise rotation on the
screen, from the positive X axis to the positive Y axis.
The function assumes space for outary has been properly
allocated.
SEE ALSO
D2SCALE, D2TRANSLATE
EXAMPLE
/*
* shows d2rotate works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point tri[3];
D2Point trio[3];
D2Point tri2[3];
void drwtri(void);
void ertri(void);
void main(void)
{
int vmode,i;
20
vmode = videomodeget();
if (!whichvga())
exit(1);
if (whichmem()<512)
exit(1);
res640();
trio[0].x = 0;
trio[0].y = 0;
trio[1].x = -80;
trio[1].y = 60;
trio[2].x = 80;
trio[2].y = 60;
drwtri();
for(i=0;i<=360;i+=2)
{
d2rotate(3,0,0,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
drwtri();
getch();
videomodeset(vmode);
exit(0);
}
void drwtri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,10,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
drwline(1,10,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,10,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
void ertri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,0,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
drwline(1,0,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,0,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
21
D2SCALE
PROTOTYPE
extern void far d2scale (int points, int scalex, int scaley,
D2Point far *inary, D2Point far *outary)
INPUT
numpoints - number of points to scale
scalex - scale factor along X axis
scaley - scale factor along Y axis
inary - D2Point pointer to array containing points to scale
OUTPUT
no value returned
outary - D2Point array of scaled values
USAGE
D2SCALE multiplies each coordinate in the two dimensional
array inary by the corresponding scale factor scalex or
scaley. The results are stored in outary which can be the
same as inary. A scale factor of 256 (100 hex) is
considered 100 percent and results in no change. Therefore,
128 (80 hex) reduces values by one half and 512 (200 hex)
doubles values. The function assumes space for outary has
been properly allocated.
SEE ALSO
D2ROTATE, D2TRANSLATE
EXAMPLE
/*
* shows d2scale works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point tri[3];
D2Point trio[3];
D2Point tri2[3];
void drwtri(void);
void ertri(void);
void main(void)
{
int vmode,i;
22
vmode = videomodeget();
if (!whichvga())
exit(1);
if (whichmem()<512)
exit(1);
res640();
trio[0].x = 0;
trio[0].y = 0;
trio[1].x = -80;
trio[1].y = 60;
trio[2].x = 80;
trio[2].y = 60;
drwtri();
for(i=256;i<=512;i+=4)
{
d2scale(3,i,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
for(i=512;i>=128;i-=4)
{
d2scale(3,i,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
for(i=128;i<=256;i+=4)
{
d2scale(3,i,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
drwtri();
getch();
videomodeset(vmode);
exit(0);
}
void drwtri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,10,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
drwline(1,10,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,10,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
void ertri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,0,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
23
drwline(1,0,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,0,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
24
D2TRANSLATE
PROTOTYPE
extern void far d2translate (int points, int xtrans, int
ytrans, D2Point far *inary, D2Point far *outary)
INPUT
numpoints - number of points to be translated
xtrans - distance to translate along X axis
ytrans - distance to translate along Y axis
inary - D2Point pointer to array containing points to
translate
OUTPUT
no value returned
outary - D2Point array of translated values
USAGE
D2TRANSLATE takes the two dimensional points given in inary
and translates them by the specified number of pixels along
each axis. The results are returned in outary which can be
the same as inary. The function assumes that space for
outary has been properly allocated.
SEE ALSO
D2ROTATE, D2SCALE
EXAMPLE
/*
* shows d2translate works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point tri[3];
D2Point trio[3];
D2Point tri2[3];
void drwtri(void);
void ertri(void);
void main(void)
{
int vmode,i;
vmode = videomodeget();
25
if (!whichvga())
exit(1);
if (whichmem()<512)
exit(1);
res640();
trio[0].x = 0;
trio[0].y = 0;
trio[1].x = -80;
trio[1].y = 60;
trio[2].x = 80;
trio[2].y = 60;
drwtri();
for(i=0;i<=100;i+=4)
{
d2translate(3,i,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
for(i=100;i>=0;i-=4)
{
d2translate(3,i,i,trio,tri);
drwtri();
sdelay(2);
ertri();
}
drwtri();
getch();
videomodeset(vmode);
exit(0);
}
void drwtri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,10,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
drwline(1,10,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,10,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
void ertri(void)
{
d2translate(3,320,240,tri,tri2);
drwline(1,0,tri2[0].x,tri2[0].y,tri2[1].x,tri2[1].y);
drwline(1,0,tri2[1].x,tri2[1].y,tri2[2].x,tri2[2].y);
drwline(1,0,tri2[2].x,tri2[2].y,tri2[0].x,tri2[0].y);
return;
}
26
D3PROJECT
PROTOTYPE
extern int far d3project (int points, ProjParameters far
*params, D3Point far *inary, D2Point far *outary)
INPUT
numpoints - number of points to be projected
params - pointer to ProjParameters structure containing
parameters used in projection
eyex, eyey, eyez - 3D location of viewer
scrd - distance from viewer to projection screen
theta - angle from positive 3D X axis to viewing
direction
phi - angle from positive 3D Z axis to viewing direction
inary - D3Point pointer to array containing points to
project
OUTPUT
Returns 1 if successful, 0 if any one point failed.
outary - D2Point array of projected values
USAGE
+Z axis
| /\
| / \
| ! \ * \
| !......X: /
| ! Phi / \/
| ! / :
| ! / :
| ! / :
| EyeX ! /ScrD :
| EyeY !/ :
| EyeZ *- - - -:- - - - -
| / ` :
| / ` :
| / ` :
| / ---` :
| /___----
| / Theta
|
|_____________________________+Y axis
/
/
/
/
/
/
/
+X axis
27
D3PROJECT projects a specified number, numpoints, of three
dimensional points starting at inary into two dimensions
according to the parameters in params. The two dimensional
points are stored in outary. The function assumes space for
outary has been properly allocated. The location of the
viewer in this three dimensional space is given by eyex,
eyey, eyez in the ProjParameters structure. The direction
the viewer is facing is specified with scrd, theta, phi in
the ProjParameters structure using spherical coordinates. A
virtual set of axes parallel to the true axes are placed at
the viewer's location. scrd is the distance from the viewer
to the center of the projection screen, i.e. the currently
defined viewport on the monitor's screen. Theta is the
angle in the virtual X-Y plane from the virtual X axis to
the projection screen. Positive angles rotate counter-
clockwise in the X-Y plane. Lastly, the angle of elevation
above or below the virtual X-Y plane is given by phi.
Positive angles direct viewing above the plane; negative
below.
If a point is projected to a location behind the viewer,
i.e. on the side of the viewer opposite the projection
screen, D3PROJECT returns a zero indicating one or more
failed points. The returned values of the X and Y for
failed points will be -32768 to make them easily identified.
SEE ALSO
D3ROTATE, D3TRANSLATE, D3SCALE, FILLCONVEXPOLY, SETVIEW
EXAMPLE
/* shows d3project works */
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point plot[8];
void drwcube(void);
void main(void)
{
int vmode,i,dummy;
ProjParameters proj;
D3Point cube[8] = { { 100,-100, 100},
{ 100,-100,-100},
{ 100, 100,-100},
{ 100, 100, 100},
{-100,-100, 100},
{-100,-100,-100},
{-100, 100,-100},
{-100, 100, 100}};
28
vmode = videomodeget();
if (!whichvga())
exit(1);
if (whichmem()<512)
exit(1);
res640();
proj.eyex = -1040;
proj.eyey = -600;
proj.eyez = -1200;
proj.scrd = 1700;
proj.theta = 30;
proj.phi = 45;
dummy = d3project(8,&proj,cube,plot);
drwcube();
getch();
videomodeset(vmode);
}
void drwcube(void)
{
int i;
for(i=0;i<=2;i++)
drwline(1,10,plot[i].x,plot[i].y,plot[i+1].x,plot[i+1].y)
;
drwline(1,10,plot[3].x,plot[3].y,plot[0].x,plot[0].y);
for(i=4;i<=6;i++)
drwline(1,10,plot[i].x,plot[i].y,plot[i+1].x,plot[i+1].y)
;
drwline(1,10,plot[7].x,plot[7].y,plot[4].x,plot[4].y);
for(i=0;i<=3;i++)
drwline(1,10,plot[i].x,plot[i].y,plot[i+4].x,plot[i+4].y)
;
return;
}
29
D3ROTATE
PROTOTYPE
extern void far d3rotate (int points, int xorigin, int
yorigin, int zorigin, int zrang, int yrang, int xrang,
D3Point far *inary, D3Point far *outary)
INPUT
numpoints - number of points to be rotated
xorigin, yorigin, zorigin - center of rotation
zrang - angle of rotation about the Z axis
yrang - angle of rotation about the Y axis
xrang - angle of rotation about the X axis
inary - D3Point pointer to array containing points to rotate
OUTPUT
no value returned
outary - D3Point array of rotated values
USAGE
D3ROTATE takes the three dimensional points given in inary
and rotates them by the specified angles about xorigin,
yorigin, zorigin. The results are returned in outary which
can be the same as inary. A virtual set of axes are placed
at the origin of rotation and rotation takes place about
these axes. A positive angle causes a counter-clockwise
rotation from the positive X axis to the positive Y axis.
The function assumes space for outary has been properly
allocated.
SEE ALSO
D3PROJECT, D3SCALE, D3TRANSLATE
EXAMPLE
/*
* shows d3rotate works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point plot[8];
void drwcube(void);
void main(void)
{
30
int vmode,i,dummy;
ProjParameters proj;
D3Point rcube[8];
D3Point cube[8] = { { 100,-100, 100},
{ 100,-100,-100},
{ 100, 100,-100},
{ 100, 100, 100},
{-100,-100, 100},
{-100,-100,-100},
{-100, 100,-100},
{-100, 100, 100}};
vmode = videomodeget();
if (!whichvga() || (whichmem() < 512))
exit(1);
res640();
proj.eyex = -1040;
proj.eyey = -600;
proj.eyez = -1200;
proj.scrd = 1700;
proj.theta = 30;
proj.phi = 45;
for(i=0;i<=360;i+=2)
{
d3rotate(8,0,0,0,i,i,i,cube,rcube);
dummy = d3project(8,&proj,rcube,plot);
drwcube();
sdelay(2);
drwcube();
}
drwcube();
getch();
videomodeset(vmode);
}
void drwcube(void)
{
int j;
for(j=0;j<=2;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
drwline(2,10,plot[3].x,plot[3].y,plot[0].x,plot[0].y);
for(j=4;j<=6;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
31
drwline(2,10,plot[7].x,plot[7].y,plot[4].x,plot[4].y);
for(j=0;j<=3;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+4].x,plot[j+4].y)
;
return;
}
32
D3SCALE
PROTOTYPE
extern void far d3scale (int points, int xscale, int yscale,
int zscale, D3Point far *inary, D3Point far *outary)
INPUT
numpoints - number of points to scale
xscale - scale factor along X axis
yscale - scale factor along Y axis
zscale - scale factor along Z axis
inary - D3Point pointer to array containing points to scale
OUTPUT
no value returned
outary - D3Point array of scaled values
USAGE
D3SCALE multiplies each coordinate in the three dimensional
array inary by the corresponding scale factor xscale, yscale
or zscale. The results are stored in outary which can be
the same as inary. A scale factor of 256 (100 hex) is
considered 100 percent and results in no change. Therefore,
128 (80 hex) reduces values by one half and 512 (200 hex)
doubles values. The function assumes space for outary has
been properly allocated.
SEE ALSO
D3PROJECT, D3ROTATE, D3TRANSLATE
EXAMPLE
/*
* shows d3scale works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point plot[8];
void drwcube(void);
void main(void)
{
int vmode,i,dummy;
ProjParameters proj;
D3Point scube[8];
33
D3Point cube[8] = { { 100,-100, 100},
{ 100,-100,-100},
{ 100, 100,-100},
{ 100, 100, 100},
{-100,-100, 100},
{-100,-100,-100},
{-100, 100,-100},
{-100, 100, 100}};
vmode = videomodeget();
if (!whichvga() || (whichmem() < 512))
exit(1);
res640();
proj.eyex = -1040;
proj.eyey = -600;
proj.eyez = -1200;
proj.scrd = 1700;
proj.theta = 30;
proj.phi = 45;
for(i=256;i>=128;i-=4)
{
d3scale(8,i,i,i,cube,scube);
dummy = d3project(8,&proj,scube,plot);
drwcube();
sdelay(2);
drwcube();
}
for(i=132;i<=256;i+=4)
{
d3scale(8,i,i,i,cube,scube);
dummy = d3project(8,&proj,scube,plot);
drwcube();
sdelay(2);
drwcube();
}
drwcube();
getch();
videomodeset(vmode);
}
void drwcube(void)
{
int j;
for(j=0;j<=2;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
drwline(2,10,plot[3].x,plot[3].y,plot[0].x,plot[0].y);
for(j=4;j<=6;j++)
34
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
drwline(2,10,plot[7].x,plot[7].y,plot[4].x,plot[4].y);
for(j=0;j<=3;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+4].x,plot[j+4].y)
;
return;
}
35
D3TRANSLATE
PROTOTYPE
extern void far d3translate (int points, int xtrans, int
ytrans, int ztrans, D3Point far *inary, D3Point far
*outary)
INPUT
numpoints - number of points to translate
xtrans - distance to translate along X axis
ytrans - distance to translate along Y axis
ztrans - distance to translate along Z axis
inary - D3Point pointer to array containing points to
translate
OUTPUT
no value returned
outary - D3Point array of translated points
USAGE
D3TRANSLATE takes the three dimensional points given in
inary and translates them by the specified number of pixels
along each axis. The results are returned in outary which
can be the same as inary. The function assumes space for
outary has been properly allocated.
SEE ALSO
D3PROJECT, D3ROTATE, D3SCALE
EXAMPLE
/*
* shows d3translate works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
D2Point plot[8];
void drwcube(void);
void main(void)
{
int vmode,i,dummy;
ProjParameters proj;
D3Point tcube[8];
D3Point cube[8] = { { 100,-100, 100},
36
{ 100,-100,-100},
{ 100, 100,-100},
{ 100, 100, 100},
{-100,-100, 100},
{-100,-100,-100},
{-100, 100,-100},
{-100, 100, 100}};
vmode = videomodeget();
if (!whichvga() || (whichmem() < 512))
exit(1);
res640();
proj.eyex = -1040;
proj.eyey = -600;
proj.eyez = -1200;
proj.scrd = 1700;
proj.theta = 30;
proj.phi = 45;
for(i=0;i<=400;i+=8)
{
d3translate(8,i,i,i,cube,tcube);
dummy = d3project(8,&proj,tcube,plot);
drwcube();
sdelay(2);
drwcube();
}
for(i=400;i>=0;i-=8)
{
d3translate(8,i,i,i,cube,tcube);
dummy = d3project(8,&proj,tcube,plot);
drwcube();
sdelay(2);
drwcube();
}
drwcube();
getch();
videomodeset(vmode);
}
void drwcube(void)
{
int j;
for(j=0;j<=2;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
drwline(2,10,plot[3].x,plot[3].y,plot[0].x,plot[0].y);
for(j=4;j<=6;j++)
37
drwline(2,10,plot[j].x,plot[j].y,plot[j+1].x,plot[j+1].y)
;
drwline(2,10,plot[7].x,plot[7].y,plot[4].x,plot[4].y);
for(j=0;j<=3;j++)
drwline(2,10,plot[j].x,plot[j].y,plot[j+4].x,plot[j+4].y)
;
return;
}
38
DRWBOX
PROTOTYPE
extern void far drwbox (PixelMode mode, int colr, int x1,
int y1, int x2, int y2)
INPUT
mode - pixel write mode
colr - index to color in current palette
x1, y1 - location of top left corner
x2, y2 - location of bottom right corner
OUTPUT
no value returned
USAGE
DRWBOX draws a rectangle with the specified color using mode
with opposite vertices defined by (x1, y1) and (x2, y2).
The vertices given do not need to be exactly the top left
and bottom right. They only have to reference opposite
vertices of the rectangle. Any portion of the rectangle
that lies outside of the currently defined viewport will not
be drawn.
SEE ALSO
DRWFILLBOX, DRWLINE, SETVIEW
EXAMPLE
/*
* Places a box around the whole screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwbox (1,10,0,0,639,479);
getch();
39
videomodeset(vmode);
exit(0);
}
40
DRWCIRCLE
PROTOTYPE
extern void far drwcircle (PixelMode mode, int colr, int
xcenter, int ycenter, int radius)
INPUT
mode - pixel write mode
colr - index to color in current palette
xcenter, ycenter - location of center of circle
radius - distance from center to edge of circle
OUTPUT
no value returned
USAGE
DRWCIRCLE draws a circle of the specified color using mode
with the center located at (xcenter, ycenter) and a radius
of radius. All values of xcenter, ycenter and radius are
valid. Any portion of the circle that lies outside of the
currently defined viewport will not be drawn.
SEE ALSO
DRWELLIPSE, DRWFILLCIRCLE, SETVIEW
EXAMPLE
/*
* Places a circle at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwcircle (1,10,320,240,200);
getch();
videomodeset(vmode);
exit(0);
41
}
42
DRWELLIPSE
PROTOTYPE
extern void far drwellipse (PixelMode mode, int colr, int
xcenter, int ycenter, int radiusx, int radiusy)
INPUT
mode - pixel write mode
colr - index to color in current palette
xcenter, ycenter - location of center of ellipse
radiusx - radius parallel to X axis
radiusy - radius parallel to Y axis
OUTPUT
no value returned
USAGE
DRWELLIPSE draws an ellipse of the specified color using
mode with the center defined by (xcenter, ycenter). The
radius in the horizontal direction is raduisx and the radius
in the vertical direction is radiusy. All values of
xcenter, ycenter, radiusx and radiusy are valid. Any
portion of the ellipse that lies outside of the currently
defined viewport will not be drawn.
SEE ALSO
DRWCIRCLE, DRWFILLELLIPSE, SETVIEW
EXAMPLE
/*
* Places an ellipse at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwellipse (1,10,320,240,318,238);
43
getch();
videomodeset(vmode);
exit(0);
}
44
DRWFILLBOX
PROTOTYPE
extern void far drwfillbox (PixelMode mode, int colr, int
x1, int y1, int x2, int y2)
INPUT
mode - pixel write mode
colr - index to color in current palette
x1, y1 - location of top left corner
x2, y2 - location of bottom right corner
OUTPUT
no value returned
USAGE
DRWFILLBOX draws a solid rectangle with the specified color
using mode with opposite vertices defined by (x1, y1) and
(x2, y2). The vertices given do not need to be exactly the
top left and bottom right. They only have to reference
opposite vertices of the rectangle. Any portion of the
rectangle that lies outside of the currently defined
viewport will not be drawn.
SEE ALSO
DRWBOX, DRWLINE, FILLCONVEXPOLY, SETVIEW
EXAMPLE
/*
* Places a filled box in the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
drwfillbox (1,10,270,190,370,290);
getch();
45
videomodeset(vmode);
exit(0);
}
46
DRWFILLCIRCLE
PROTOTYPE
extern void far drwfillcircle (PixelMode mode, int colr, int
xcenter, int ycenter, int radius)
INPUT
mode - pixel write mode
colr - index to color in current palette
xcenter, ycenter - location of center of circle
radius - distance from center to edge of circle
OUTPUT
no value returned
USAGE
DRWFILLCIRCLE draws a solid circle of the specified color
using mode with the center located at (xcenter, ycenter) and
a radius of radius. All values of xcenter, ycenter and
radius are valid. Any portion of the circle that lies
outside of the currently defined viewport will not be drawn.
SEE ALSO
DRWCIRCLE, SETVIEW
EXAMPLE
/*
* Places a filled circle at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
drwfillcircle (1,10,320,240,100);
getch();
videomodeset(vmode);
exit(0);
47
}
48
DRWFILLELLIPSE
PROTOTYPE
extern void far drwfillellipse (PixelMode mode, int colr,
int xcenter, int ycenter, int radiusx, int radiusy)
INPUT
mode - pixel write mode
colr - index to color in current palette
xcenter, ycenter - location of center of ellipse
radiusx - radius parallel to X axis
radiusy - radius parallel to Y axis
OUTPUT
no value returned
USAGE
DRWFILLELLIPSE draws an ellipse of the specified color using
mode with the center defined by (xcenter, ycenter). The
radius in the horizontal direction is raduisx and the radius
in the vertical direction is radiusy. All values of
xcenter, ycenter, radiusx and radiusy are valid. Any
portion of the ellipse that lies outside of the currently
defined viewport will not be drawn.
SEE ALSO
DRWELLIPSE, SETVIEW
EXAMPLE
/*
* Places a filled ellipse at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
drwfillellipse (1,10,320,240,218,138);
49
getch();
videomodeset(vmode);
exit(0);
}
50
DRWLINE
PROTOTYPE
extern void far drwline (PixelMode mode, int colr, int x1,
int y1, int x2, int y2)
INPUT
mode - pixel write mode
colr - index to color in current palette
x1, y1 - location of one endpoint of line
x2, y2 - location of other endpoint of line
OUTPUT
no value returned
USAGE
DRWLINE draws a line of the specified color using mode with
endpoints located at (x1, y1) And (x2, y2). All values of
x1, y1, x2 and y2 are valid. Any portion of the line that
lies outside of the currently defined viewport will not be
drawn.
SEE ALSO
DRWBOX, SETVIEW
EXAMPLE
/*
* Draws a line from 0,0 to the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwline (1,10,0,0,320,240);
getch();
videomodeset(vmode);
exit(0);
}
51
DRWPOINT
PROTOTYPE
extern void far drwpoint (PixelMode mode, int colr, int x,
int y)
INPUT
mode - pixel write mode
colr - index to color in current palette
x, y - location of pixel to write
OUTPUT
no value returned
USAGE
DRWPOINT draws a single point of the specified color using
mode at (x, y). All values of x and y are valid. If the
point (x, y) lies outside of the currently defined viewport,
no drawing will take place.
SEE ALSO
GETPOINT, SETVIEW
EXAMPLE
/*
* Draws a point at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwpoint (1,10,320,240);
getch();
videomodeset(vmode);
exit(0);
}
52
DRWSTRING
PROTOTYPE
extern void far drwstring (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y)
INPUT
mode - pixel write mode
fcolr - foreground index to color in current palette
bcolr - background index to color in current palette
strng - char pointer to string of ASCII characters to be
drawn
x, y - location of upper, left corner of block
OUTPUT
no value returned
USAGE
DRWSTRING takes the null terminated ASCII characters
beginning at strng and creates a graphics block similar to
the blocks used by blkget and blkput and places this block
on the screen at the specified coordinates. The characters
are drawn with color fcolr using the current font and the
background is color bcolr. When mode 0, NO_ACTION, is used,
the graphics block is created in memory, retrievable by
GETLASTSTRING, but no text is actually drawn on the screen.
(Note: the system font is automatically installed when
WHICHVGA is called.)
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRINGDN, DRWSTRINGLT,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
/*
* Draws some normal text at the center of the screen
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
char text[]="hello world";
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
53
exit(1);
res640();
drwstring(1,10,0,text,320,240);
getch();
videomodeset(vmode);
exit(0);
}
54
DRWSTRINGDN
PROTOTYPE
extern void far drwstringdn (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y)
INPUT
mode - pixel write mode
fcolr - foreground index to color in current palette
bcolr - background index to color in current palette
strng - char pointer to string of ASCII characters to be
drawn
x, y - location of lower, right corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGDN takes the null terminated ASCII characters
beginning at strng and creates a graphics block similar to
the blocks used by BLKGET and BLKPUT. The characters are
drawn with color fcolr using the current font and the
background is color bcolr. When mode 0, NO_ACTION, is used,
the graphics block is created in memory retrievable by
GETLASTSTRING, but no text is actually drawn on the screen.
(Note: the system font is automatically installed when
WHICHVGA is called.) The text is drawn upside down with x,
y specifying the lower, right corner. This corner
corresponds to the upper, left corner when the text is
oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGLT,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
/* Draws some text rotated by 180 degrees at the center of
the screen */
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
char text[]="hello world";
vmode = videomodeget();
55
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwstringdn(1,10,0,text,320,240);
getch();
videomodeset(vmode);
exit(0);
}
56
DRWSTRINGLT
PROTOTYPE
extern void far drwstringlt (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y)
INPUT
mode - pixel write mode
fcolr - foreground index to color in current palette
bcolr - background index to color in current palette
strng - char pointer to string of ASCII characters to be
drawn
x, y - location of lower, left corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGLT takes the null terminated ASCII characters
beginning at strng and creates a graphics block similar to
the blocks used by BLKGET and BLKPUT. The characters are
drawn with color fcolr using the current font and the
background is color bcolr. When mode 0, NO_ACTION, is used,
the graphics block is created in memory retrievable by
GETLASTSTRING, but no text is actually drawn on the screen.
(Note: the system font is automatically installed when
WHICHVGA is called.) The text block is rotated 90 to the
left with x, y specifying the lower, left corner. This
corner corresponds to the upper, left corner when the text
is oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGDN,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
/* Draws some text rotated 90 degrees to the left at center
of screen */
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
char text[]="hello world";
vmode = videomodeget();
57
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwstringlt(1,10,0,text,320,240);
getch();
videomodeset(vmode);
exit(0);
}
58
DRWSTRINGRT
PROTOTYPE
extern void far drwstringrt (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y)
INPUT
mode - pixel write mode
fcolr - foreground index to color in current palette
bcolr - background index to color in current palette
strng - char pointer to string of ASCII characters to be
drawn
x, y - location of upper, right corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGRT takes the null terminated ASCII characters
beginning at strng and creates a graphics block similar to
the blocks used by BLKGET and BLKPUT. The characters are
drawn with color fcolr using the current font and the
background is color bcolr. When mode 0, NO_ACTION, is used,
the graphics block is created in memory retrievable by
GETLASTSTRING, but no text is actually drawn on the screen.
(Note: the system font is automatically installed when
WHICHVGA is called.) The text block is rotated 90 to the
right with x, y specifying the upper, right corner. This
corner corresponds to the upper, left corner if the text is
oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGDN,
DRWSTRINGLT, GETLASTSTRING
EXAMPLE
/* Draws text rotated 90 degrees to the right at center of
screen */
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
char text[]="hello world";
vmode = videomodeget();
59
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwstringrt(1,10,0,text,320,240);
getch();
videomodeset(vmode);
exit(0);
}
60
FILLAREA
PROTOTYPE
extern void far fillarea (int xseed, int yseed, int
bordercolr, int fillcolr)
INPUT
xseed, yseed - seed location to start fill
bordercolr - index to color in current palette at which
filling stops
fillcolr - index to color in current palette to fill within
the border
OUTPUT
no value returned
USAGE
FILLAREA fills a region with a new color specified by
fillcolr. The region is defined by any line or curve of the
color bordercolr or fillcolr or by the edge of the viewport.
All graphics within the region are lost and covered with the
fillcolr. The border is not effected.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLCOLOR,
FILLCONVEXPOLY, FILLPAGE, FILLSCREEN, FILLVIEW, SETVIEW
EXAMPLE
/*
* fills a box with some color
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwbox(1,10,0,0,100,100);
fillarea(1,1,10,7);
61
getch();
videomodeset(vmode);
exit(0);
}
62
FILLCOLOR
PROTOTYPE
extern void far fillcolor (int xseed, int yseed, int
oldcolr, int newcolr)
INPUT
xseed, yseed - seed location to start fill
oldcolr - index to color in current palette to change
newcolr - index to color in current palette to replace
oldcolr
OUTPUT
no value returned
USAGE
FILLCOLOR replaces every existence of oldcolr with newcolr
within a region. The region is defined as any pixel of
oldcolr which has a path of pixels of oldcolr or newcolr
with sides touching back to the seed point, (xseed, yseed).
Therefore, only pixels of oldcolr are modified and no other
information is changed.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCONVEXPOLY, FILLPAGE, FILLSCREEN, FILLVIEW, SETVIEW
EXAMPLE
/*
* replaces the black color with a new color
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwbox(1,10,0,0,100,100);
drwbox(1,12,20,20,80,80);
63
fillcolor(1,1,0,7);
getch();
videomodeset(vmode);
exit(0);
}
64
FILLCONVEXPOLY
PROTOTYPE
SUB FILLCONVEXPOLY (PolyColor%, NumPoints%, PointArray%)
INPUT
PolyColor - index to color in current palette
NumPoints - number of points in PointArray
PointArray - P2DType array holding points of polygon
OUTPUT
no value returned
USAGE
FILLCONVEXPOLY draws a solid polygon outlined by the points
given in PointArray. The points are expected to be
consecutive and the resulting polygon should be convex (ie.
the polygon should not curve in on itself like a kidney
bean). The function also assumes that the last point in the
array connects to the first.
SEE ALSO
D3PROJECT, DRWFILLBOX, FILLAREA, FILLCOLOR, FILLPAGE,
FILLSCREEN, FILLVIEW
EXAMPLE
/*
* Show fillconvexpoly
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
#define randnum(size) (rand() % (int)(size))
D2Point tri[3];
void main(void)
{
int vmode,colr,i;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
65
exit(1);
for(i=0;i<99;i++) {
tri[0].x = randnum(maxx);
tri[0].y = randnum(maxy);
tri[1].x = randnum(maxx);
tri[1].y = randnum(maxy);
tri[2].x = randnum(maxx);
tri[2].y = randnum(maxy);
colr = randnum(15);
fillconvexpoly(colr,3,tri);
}
getch();
videomodeset(vmode);
exit(0);
}
66
FILLPAGE
PROTOTYPE
extern void far fillpage (int colr)
INPUT
colr - index to color in current palette
OUTPUT
no value is returned
USAGE
FILLPAGE clears the currently active page with the specified
color. All information on the page is lost. (Note, a
faster method to clear the page is to call any of the RES###
functions. These reset the graphics screen and
automatically clear it to color index zero as well as reset
the default palette.)
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLCONVEXPOLY, FILLSCREEN, FILLVIEW
EXAMPLE
/*
* fill the page with a color
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
fillpage(10);
getch();
videomodeset(vmode);
exit(0);
}
67
FILLSCREEN
PROTOTYPE
extern void far fillscreen (int colr)
INPUT
colr - index to color in current palette
OUTPUT
no value is returned
USAGE
FILLSCREEN clears the entire screen with the specified
color. All information on the screen is lost. (Note, a
faster method to clear the screen is to call any of the
RES### functions. These reset the graphics screen and
automatically clear it to color index zero as well as reset
the default palette.)
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLCONVEXPOLY, FILLPAGE, FILLVIEW
EXAMPLE
/*
* fill the screen with a color
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
fillscreen(10);
getch();
videomodeset(vmode);
exit(0);
}
68
FILLVIEW
PROTOTYPE
extern void far fillview (int colr)
INPUT
colr - index to color in current palette
OUTPUT
no value is returned
USAGE
FILLVIEW fills the currently defined viewport with the
specified color. All information in the viewport is lost.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLCONVEXPOLY, FILLPAGE, FILLSCREEN, SETVIEW
EXAMPLE
/*
* fill the viewport with a color
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
setview(100,100,539,379);
fillview(10);
getch();
videomodeset(vmode);
exit(0);
}
69
FONTGETINFO
PROTOTYPE
extern void far fontgetinfo (int far *wdth, int far *hght)
INPUT
no input parameters
OUTPUT
wdth - integer pointer to width in pixels of current font
hght - integer pointer to height in pixels of current font
USAGE
FONTGETINFO returns in wdth and hght the dimensions of the
currently loaded font.
SEE ALSO
FONTSET, FONTSYSTEM
EXAMPLE
/*
* display system font width and height
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int fontwidth;
int fontheight;
char text[50];
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
fontgetinfo(&fontwidth,&fontheight);
sprintf(text,"the system font width is: %d",fontwidth);
drwstring(1,7,0,text,0,0);
sprintf(text,"the system font height is: %d",fontheight);
drwstring(1,7,0,text,0,20);
getch();
videomodeset(vmode);
70
exit(0);
}
71
FONTSET
PROTOTYPE
extern void far fontset (Font far *font)
INPUT
font - pointer to Font structure
OUTPUT
no value returned
USAGE
FONTSET loads the current font with the data found at font.
The Font structure is 4098 bytes long with the first two
bytes being the width and height of the font respectively.
SEE ALSO
FONTGETINFO, FONTSYSTEM
EXAMPLE
/*
* Load a font from disk and enable it
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include "svgacc.h"
Font newfont;
void main(void)
{
int vmode;
char text[]="The Dragon Font!";
FILE *fontfile;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
if( (fontfile = fopen("dragon.fnt","rb")) == NULL )
exit (1);
fread(&newfont,4098,1,fontfile);
fclose(fontfile);
fontset(&newfont);
72
drwstring(1,10,0,text,0,0);
getch();
videomodeset(vmode);
}
73
FONTSYSTEM
PROTOTYPE
extern void far fontsystem (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
FONTSYSTEM sets the current font to the standard system
font. This font is automatically set when WHICHVGA is
called.
SEE ALSO
WHICHVGA, FONTGETINFO, FONTSET
EXAMPLE
/* Load font from disk, enable it, and switch back to system
font */
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include "svgacc.h"
Font newfont;
void main(void)
{
int vmode;
char text1[]="The Dragon Font!";
char text2[]="The System Font!";
FILE *fontfile;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !res640() )
exit(1);
if( (fontfile = fopen("dragon.fnt","rb")) == NULL )
exit(1);
fread(&newfont,4098,1,fontfile);
fclose(fontfile);
fontset(&newfont);
drwstring(1,10,0,text1,0,0);
fontsystem();
74
drwstring(1,10,0,text2,0,20);
getch();
videomodeset(vmode);
}
75
GETARCCOS
PROTOTYPE
extern long far getarccos (long cosvalue)
INPUT
cosvalue - number between -1 and +1 scaled up by 13 bits
(8192)
OUTPUT
GETARCCOS returns the arc cosine of cosvalue in degrees.
USAGE
GETARCCOS returns the arc cosine in degrees for the given
value. The return will be between 0 and 180 degrees.
Cosvalue should be between -8192 and +8192 representing the
range -1 to +1. Input values outside this range are invalid
and GETARCCOS will return -32768. This function uses an
integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCSIN, GETARCTAN, GETCOS, GETSIN, GETTAN
EXAMPLE
/*
* show getarccos
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int ang;
long valueX8192;
float value;
for(value=0;value<1;value+=.05)
{
valueX8192 = 8192 * value;
ang = getarccos(valueX8192);
printf("arccos of %f = %d degrees\n",value,ang);
76
}
exit(0);
}
77
GETARCSIN
PROTOTYPE
extern long far getarcsin (long sinvalue)
INPUT
sinvalue - number between -1 and +1 scaled up by 13 bits
(8192)
OUTPUT
GETARCSIN returns the arc sine of sinvalue in degrees.
USAGE
GETARCSIN returns the arc sine in degrees for the given
value. The return will be between -90 and +90 degrees.
Sinvalue should be between -8192 and +8192 representing the
range -1 to +1. Input values outside this range are invalid
and GETARCSIN will return -32768. This function uses an
integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCCOS, GETARCTAN, GETCOS, GETSIN, GETTAN
EXAMPLE
/*
* show getarcsin
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int ang;
long valueX8192;
float value;
for(value=0;value<1;value+=.05)
{
valueX8192 = 8192 * value;
ang = getarcsin(valueX8192);
printf("arcsin of %f = %d degrees\n",value,ang);
78
}
exit(0);
}
79
GETARCTAN
PROTOTYPE
extern long far getarctan (long tanvalue)
INPUT
tanvalue - long integer representing a decimal scaled up by
13 bits (8192)
OUTPUT
GETARCTAN returns the arc tangent of tanvalue in degrees.
USAGE
GETARCTAN returns the arc tangent in degrees for the given
value. The return will be between -89 and +89 degrees.
Tanvalue can be any long integer. It is interpreted as a
decimal scaled up by 8192 (13 bits). This function uses an
integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETCOS, GETSIN, GETTAN
EXAMPLE
/*
* show getarctan
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int tanang;
int ang;
long valueX8192;
float value;
for(value=0;value<2;value+=.1)
{
valueX8192 = 8192 * value;
ang = getarctan(valueX8192);
printf("arctan of %f = %d degrees\n",value,ang);
80
}
exit(0);
}
81
GETCOS
PROTOTYPE
extern long far getcos (long angle)
INPUT
angle - angle in degrees
OUTPUT
GETCOS returns the cosine of angle scaled up by 13 bits
(8192).
USAGE
GETCOS returns the cosine of the specified angle. Angle can
be any long value. The return value has been multiplied by
8192. This function uses an integer lookup table stored
within the library in order to produce the fastest possible
results. No floating point arithmetic is used. The scale
factor of 13 bits (8192) was chosen because this is the
number of bits at which every change of one degree gives a
change in the value of the sine (or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETSIN, GETTAN
EXAMPLE
/*
* show getcos
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int ang;
float value;
for(ang=0;ang<90;ang+=5)
{
value = (float)getcos(ang) / 8192;
printf("cos of %d degrees = %f\n",ang,value);
}
exit(0);
}
82
GETLASTSTRING
PROTOTYPE
extern void far getlaststring (RasterBlock far *strnggfxblk)
INPUT
no input parameters
OUTPUT
no value returned
strnggfxblk - RasterBlock pointer to destination array
USAGE
GETLASTSTRING returns the text drawn on the screen by the
last called DRWSTRING function. The text is returned in
strnggfxblk which may be used with BLKPUT or the sprite
functions. The text in strnggfxblk is oriented in the same
manner as the last called DRWSTRING function. The suggested
practice is to call the DRWSTRING function using mode
NO_ACTION which does not actually draw text on the screen.
GETLASTSTRING should be called immediately after the desired
DRWSTRING function to prevent possible loss of data caused
by other functions.
The number of bytes of raster data needed by strnggfxblk is
equal to
(fontwidth*stringlength)*(fontheight)
plus four bytes for the width and height integers in the
RasterBlock structure.
The font's dimensions can be obtained by calling FONTGETINFO
and the string's length can be obtained using the STRLEN
function. Note, however, that strnggfxblk can be quite
large. If insufficient space is allocated for strnggfxblk,
GETLASTSTRING will overwrite any data in memory contained
beyond strnggfxblk and may possibly cause the system to
crash.
SEE ALSO
BLKPUT, DRWSTRING, DRWSTRINGDN, DRWSTRINGLT, DRWSTRINGRT,
FONTGETINFO
EXAMPLE
/*
* Draws some text using the 'NO-ACTION' mode then
* retrieve the raster data as a 'RasterBlock'
83
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode,fontwidth,fontheight;
char text[]="hello world";
RasterBlock *blkdata;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !res640() )
exit(1);
drwstringrt(NO_ACTION,10,0,text,320,240);
fontgetinfo(&fontwidth,&fontheight);
blkdata = (RasterBlock *)malloc(fontwidth*11*fontheight +
4);
getlaststring(blkdata);
blkput(SET,0,0,blkdata);
getch();
videomodeset(vmode);
}
84
GETPOINT
PROTOTYPE
extern int far getpoint (int x, int y)
INPUT
x, y - location of pixel to read
OUTPUT
GETPOINT returns the color index of the pixel at x, y.
USAGE
GETPOINT returns the value of the pixel at location x, y.
This value is a color index into the current palette.
SEE ALSO
DRWPOINT
EXAMPLE
/*
* draw a point and check that it is there
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int pointvalue;
char text[50];
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
drwpoint(1,10,320,240);
pointvalue = getpoint(320,240);
sprintf(text,"the point value is: %d",pointvalue);
drwstring(1,7,0,text,0,0);
getch();
videomodeset(vmode);
exit(0);
}
85
GETSIN
PROTOTYPE
extern long far getsin (long angle)
INPUT
angle - angle in degrees
OUTPUT
GETSIN returns the sine of angle scaled up by 13 bits
(8192).
USAGE
GETSIN returns the sine of the specified angle. Angle can
be any long value. The return value has been multiplied by
8192. This function uses an integer lookup table stored
within the library in order to produce the fastest possible
results. No floating point arithmetic is used. The scale
factor of 13 bits (8192) was chosen because this is the
number of bits at which every change of one degree gives a
change in the value of the sine (or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETCOS, GETTAN
EXAMPLE
/*
* show getsin
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int sinang, ang;
float value;
for(ang=0;ang<90;ang+=5)
{
value = (float)getsin(ang) / 8192;
printf("sin of %d degrees = %f\n",ang,value);
}
exit(0);
}
86
GETTAN
PROTOTYPE
extern long far gettan (long angle)
INPUT
angle - angle in degrees
OUTPUT
GETTAN returns the tangent of angle scaled up by 13 bits
(8192)
USAGE
GETTAN returns the tangent of the specified angle. Angle
can be any long value except +(90+n*180), where n is an
integer. The return value has been multiplied by 8192. If
an invalid angle is given, the GETTAN will return &H80000000
(-2147483648). This function uses an integer lookup table
stored within the library in order to produce the fastest
possible results. No floating point arithmetic is used.
The scale factor of 13 bits (8192) was chosen because this
is the number of bits at which every change of one degree
gives a change in the value of the sine (or cosine)
function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETCOS, GETSIN
EXAMPLE
/*
* show gettan
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int tanang, ang;
float value;
for(ang=0;ang<90;ang+=5)
{
value = (float)gettan(ang) / 8192;
printf("tan of %d degrees = %f\n",ang,value);
}
exit(0);
87
}
88
GIFGETINFO
PROTOTYPE
extern int far gifgetinfo (const char far *name, int far
*gifxsize, int far *gifysize, int far *numcolors, RGB far
*pal)
INPUT
name - char pointer to the filename of the GIF image to read
OUTPUT
GIFGETINFO returns 1 if successful, error code otherwise.
gifxsize - width in pixels of the image
gifysize - height in pixels of the image
numcolors - number of colors in the image palette
palette - copy of image palette
USAGE
GIFGETINFO reads name and returns the characteristics of the
image. The dimensions of the image are returned in
gifxsize, gifysize. The number of colors in the image's
palette is returned in numcolors and the palette is returned
in palette. Although the image's palette may contain less
than 256 colors, palette must be 768 bytes in length. The
image's palette will begin with the first color in Palette.
For ease of programming the GIF decoder requires that the
image be non-interlaced, use only a global color map and be
compressed according to GIF87A specifications.
If GIFGETINFO determines that Filename is a satisfactory
file, the function will return a one. Otherwise, the
function will return one of several error codes as listed
below:
0 = does not exist or there is some disk I/O problem
-1 = does not have the GIF87A signature
-2 = image is interlaced
-3 = does not use a global color map
-4 = has some general error
SEE ALSO
GIFMAKE, GIFPUT
EXAMPLE
/*
* show the info on the 'uttower.gif' GIF file
*/
89
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, xsize, ysize, numcol, ok;
int i, darkcolor, britecolor, currcolor;
PaletteData gifpal;
char buf[80];
char fname[] = "uttower.gif";
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
ok = gifgetinfo(fname,&xsize,&ysize,&numcol,gifpal);
if (ok == 1) {
if ( !res640() )
exit(1);
/* we have an unknown 8 bit palette and we must cut it
down to
6 bits and find the brightest and darkest colors */
darkcolor = 0 + 0 + 0;
britecolor = 63 + 63 + 63;
for(i=0;i<255;i++) {
gifpal[i].r >>= 2;
gifpal[i].g >>= 2;
gifpal[i].b >>= 2;
currcolor = gifpal[i].r + gifpal[i].g + gifpal[i].b;
if (currcolor > darkcolor)
darkcolor = currcolor;
if (currcolor < britecolor)
britecolor = currcolor;
}
palset(gifpal,0,255);
fillscreen(darkcolor);
sprintf(buf,"'%s' is identified as a 'Non-interlaced'
type 'GIF87a' GIF image.",fname);
drwstring(1,britecolor,darkcolor,buf,0,0);
sprintf(buf,"Dimensions are: %d pixels wide and %d
pixels high.",xsize,ysize);
drwstring(1,britecolor,darkcolor,buf,0,16);
sprintf(buf,"Number of colors: %d.",numcol);
drwstring(1,britecolor,darkcolor,buf,0,32);
gifput(SET,100,100,fname);
} else {
printf("error in GIF file, error code: %d\n",ok);
}
getch();
videomodeset(vmode);
90
}
91
GIFMAKE
PROTOTYPE
extern int far gifmake (int x1, int y1, int x2, int y2,
const char far *name)
INPUT
x1, y1 - the location of the top, left corner of the image
x2, y2 - the bottom, right corner of the image
name - filename to store the GIF image
OUTPUT
GIFMAKE returns a 1 if successful, 0 if unsuccessful.
USAGE
GIFMAKE takes the bitmap enclosed in the box defined by (x1,
y1) - (x2, y2) and writes a GIF with the filename specified
by name. The resulting file uses the GIF87a compression
specifications. The values x1, y1, x2 and y2 must be valid
coordinates on the currently active page. Name may specify
a full path and drive letter, if necessary.
SEE ALSO
GIFGETINFO, GIFPUT
EXAMPLE
/*
* Make a simple GIF file
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
#define randnum(size) (rand() % (int)(size))
void main(void)
{
int vmode,colr,num,i;
int x1,y1,x2,y2,er;
char text[]="This GIF was made using Zephyr Software's
GIFMAKE function!";
char fname[]="test.gif";
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !res640() )
exit(1);
92
fillscreen(10);
colr = 1;
for(i=0;i<200;i++) {
x1 = randnum(maxx);
y1 = randnum(maxy);
x2 = randnum(maxx);
y2 = randnum(maxy);
drwline(1,colr++,x1,y1,x2,y2);
if (colr>15)
colr = 1;
}
drwbox(SET,15,0,0,maxx,maxy);
drwstring(1,15,0,text,60,10);
er = gifmake(0,0,maxx,maxy,fname);
if (er != 1 ) {
videomodeset(vmode);
exit(1);
}
videomodeset(vmode);
exit(0);
}
93
GIFPUT
PROTOTYPE
extern int far gifput (PixelMode mode, int xloc, int yloc,
const char far *name)
INPUT
mode - pixel write mode
xloc, yloc - the location of the top, left corner of the GIF
image
name - char pointer to filename of the GIF image to read
OUTPUT
GIFPUT returns 1 if successful, error code otherwise.
USAGE
GIFPUT reads the GIF image from name and places it on the
screen with the top, left corner at xloc, yloc. The image
is automatically clipped to the currently defined viewport.
The image's palette should be previously obtained by using
GIFGETINFO.
For ease of programming the GIF decoder requires that the
image be non-interlaced, use only a global color map and be
compressed according to the GIF87A specifications.
If GIFPUT encounters no problems, the function will return a
one. Otherwise, the function will return one of several
error codes as listed below:
0 = does not exist or there is some disk I/O problem
-1 = does not have the GIF87A signature
-2 = image is interlaced
-3 = does not use a global color map
-4 = has some general error
SEE ALSO
GIFGETINFO, GIFMAKE, SETVIEW
EXAMPLE
See GIFGETINFO
94
JOYSTICKINFO
PROTOTYPE
extern void far joystickinfo (int far *jax, int far *jay,
int far *jabuts, int far *jbx, int far *jby, int far
*jbbuts)
INPUT
no input parameters
OUTPUT
jax, jay - horizontal and vertical values of joystick A
jabuts - button status of joystick A
jbx, jby - horizontal and vertical values of joystick B
jbbuts - button status of joystick B
USAGE
JOYSTICKINFO returns the current status of the two
joysticks' position and buttons. The position is returned
in jax, jay for joystick A and jbx, jby for joystick B. The
buttons' status is held in jabuts and jbbuts. For each
joystick, button A - usually the fire button - is held in
bit zero and button B is in bit one. Button status is most
easily checked with a bitwise AND of jabuts (or jbbuts) and
the desired bit.
Not all joysticks are constructed with the same components.
In addition, joysticks are not linear devices. The value of
a joystick's center will not necessarily be the mean of its
extreme values. Therefore, it is recommended that any
program using the joystick for more than just directional
control complete a calibration of the joystick prior to
usage. For an example of joystick calibration, see the
SVGADEMO.EXE source code.
It is recommended, though not required, to call
WHICHJOYSTICK, prior to using the joysticks in order to
verify the existence of the hardware.
SEE ALSO
WHICHJOYSTICK
EXAMPLE
/*
* show joysticks port readings
*/
#include <stdlib.h>
95
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int jax, jay, jabuts, jbx, jby, jbbuts;
printf("A: X Y btn | B: X Y btn\n ");
while(!kbhit()) {
joystickinfo(&jax,&jay,&jabuts,&jbx,&jby,&jbbuts);
printf("%04d %04d %1d | ",jax,jay,jabuts);
printf("%04d %04d %1d",jbx,jby,jbbuts);
printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
}
getch();
}
96
MOUSEBUTPRESS
PROTOTYPE
extern void far mousebutpress (int reqbut, int far *xloc,
int far *yloc, int far *num, int far *mbuts)
INPUT
reqbut - button for which information is requested
OUTPUT
x, y - current location of mouse cursor
num - number of times requested button has been pressed
since last request
mbuts - current status of mouse buttons
USAGE
MOUSEBUTPRESS returns in Num the number of times a mouse
button has been pressed since the last call to
MOUSEBUTPRESS. In addition the current status of the mouse
cursor and buttons is returned. The position is returned in
X, Y. The buttons' status is held in mbuts. The left
button is held in bit zero, right button in bit one and
center button - for three button mice - in bit two. Button
status is most easily checked with a bitwise AND of mbuts
and the desired bit. The button for which a history is
desired is identified by the bits in reqbut. However, only
one bit in reqbut may be set. Therefore, only the values of
1, 2 and 4 are permitted. If more than one bit in reqbut is
set, the function will exit and no information will be
returned.
SEE ALSO
MOUSEBUTRELEASE, MOUSESTATUS
EXAMPLE
/* enable,show mouse / display left button press history for
the last 2
* seconds
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, x, y, n, mbuts;
char text[50];
97
char textclr[]="
";
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mousecursordefault();
mouseenter();
mouseshow();
while(!kbhit())
{
mousebutpress(1,&x,&y,&n,&mbuts);
sprintf(text,"mouse x loc: %3d, y loc: %3d, number of
times: %2d",x,y,n);
mousehide();
drwstring(1,15,8,text,0,0);
mouseshow();
sdelay(80);
mousehide();
drwstring(1,15,8,textclr,0,0);
mouseshow();
}
mousehide();
mouseexit();
videomodeset(vmode);
exit(0);
}
98
MOUSEBUTRELEASE
PROTOTYPE
extern void far mousebutrelease (int reqbut, int far *xloc,
int far *yloc, int far *num, int far *mbuts)
INPUT
reqbut - button for which information is requested
OUTPUT
x, y - current location of mouse cursor
num - number of times requested button has been released
since last request
mbuts - current status of mouse buttons
USAGE
MOUSEBUTRELEASE returns in Num the number of times a mouse
button has been released since the last call to
MOUSEBUTRELEASE. In addition the current status of the
mouse cursor and buttons is returned. The position is
returned in x, y. The buttons' status is held in mbuts.
The left button is held in bit zero, right button in bit one
and center button - for three button mice - in bit two.
Button status is most easily checked with a bitwise AND of
mbuts and the desired bit. The button for which a history
is desired is identified by the bits in reqbut. However,
only one bit in reqbut may be set. Therefore, only the
values of 1, 2 and 4 are permitted. If more than one bit in
reqbut is set, the function will exit and no information
will be returned.
SEE ALSO
MOUSEBUTPRESS, MOUSESTATUS
EXAMPLE
/* enable,show mouse / display left button release history
for the last
* 2 seconds
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, x, y, n, mbuts;
char text[50];
99
char textclr[]="
";
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mousecursordefault();
mouseenter();
mouseshow();
while(!kbhit())
{
mousebutrelease(1,&x,&y,&n,&mbuts);
sprintf(text,"mouse x loc: %3d, y loc: %3d, number of
times: %2d",x,y,n);
mousehide();
drwstring(1,15,8,text,0,0);
mouseshow();
sdelay(80);
mousehide();
drwstring(1,15,8,textclr,0,0);
mouseshow();
}
mousehide();
mouseexit();
videomodeset(vmode);
exit(0);
}
100
MOUSECURSORSET
PROTOTYPE
extern void far mousecursorset (MouseCursor far
*mousecursor)
INPUT
mousecursor - MouseCursor pointer to mouse cursor data
OUTPUT
no value returned
USAGE
MOUSECURSORSET defines the cursor according to the data in
the MouseCursor structure. The hot spot for the cursor is
set by mousecursor.hotspotx, mousecursor.hotspoty. The
values for mousecursor.hotspotx and mousecursor.hotspoty
must be within the cursor. Valid mousecursor.hotspotx
values are from 0 to 15 and mousecursor.hotspoty ranges from
0 to 23.
SEE ALSO
MOUSECURSORDEFAULT, MOUSEENTER, MOUSESHOW
EXAMPLE
/*
* enable,show mouse, and switch to a different mouse cursor
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
MouseCursor bigmousecursor = {
1,1,
0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255
,
0,15,15,0,0,255,255,255,255,255,255,255,255,255,255,255,
0,15,15,15,15,0,0,0,255,255,255,255,255,255,255,255,
0,15,15,15,15,15,15,15,0,0,255,255,255,255,255,255,
0,15,15,15,15,15,15,15,15,15,0,0,0,255,255,255,
0,15,15,15,15,15,15,15,15,15,15,15,15,0,0,255,
101
0,15,15,15,15,15,15,15,15,15,15,15,15,15,0,255,
0,15,15,15,15,15,15,15,15,15,15,15,0,0,255,255,
0,15,15,15,15,15,15,15,15,15,15,0,255,255,255,255,
0,15,15,15,15,15,15,15,15,0,0,255,255,255,255,255,
0,15,15,15,15,15,15,15,15,0,255,255,255,255,255,255,
0,15,15,15,15,15,0,15,15,15,0,255,255,255,255,255,
0,15,15,15,15,0,0,15,15,15,0,255,255,255,255,255,
0,15,15,0,0,255,255,0,15,15,15,0,255,255,255,255,
0,15,0,255,255,255,255,0,15,15,15,0,255,255,255,255,
0,0,255,255,255,255,255,255,0,15,15,15,0,255,255,255,
255,255,255,255,255,255,255,255,255,0,15,15,15,0,255,255,
255,255,255,255,255,255,255,255,255,0,15,15,15,0,255,255,
255,255,255,255,255,255,255,255,255,255,0,15,15,15,0,255,
255,255,255,255,255,255,255,255,255,255,255,0,15,15,15,0,
255,255,255,255,255,255,255,255,255,255,255,0,15,15,15,0,
255,255,255,255,255,255,255,255,255,255,255,255,0,15,15,0
,
255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0
,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,2
55,255
};
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mouseenter();
drwstring(1,7,0,"press a key to return to default
cursor",0,0);
mousecursorset(bigmousecursor);
mouseshow();
getch();
mousecursordefault();
drwstring(1,7,0,"press a key to end
",0,0);
getch();
mousehide();
mouseexit();
videomodeset(vmode);
exit(0);
}
102
MOUSECURSORDEFAULT
PROTOTYPE
extern void far mousecursordefault (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSECURSORDEFAULT defines the mouse cursor to be a small
arrow with the hot spot in the upper, left corner. This is
the cursor set when MOUSEENTER is called.
SEE ALSO
MOUSECURSORSET, MOUSEENTER
EXAMPLE
See MOUSECURSORSET
103
MOUSEENTER
PROTOTYPE
extern void far mouseenter (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEENTER must be called before any other mouse functions.
It initializes all of the mouse abilities including
installing the Zephyr mouse display driver. MOUSEENTER
initializes the default mouse cursor, the default
sensitivity and sets the range to the current screen
resolution. The mouse cursor location is set to the middle
of the screen.
SEE ALSO
MOUSEEXIT, MOUSEHIDE, MOUSESHOW
EXAMPLE
/*
* enable,show mouse
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mouseenter();
mouseshow();
getch();
mousehide();
mouseexit();
104
videomodeset(vmode);
exit(0);
}
105
MOUSEEXIT
PROTOTYPE
extern void far mouseexit (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEEXIT properly disables all of the mouse abilities.
This function also removes the Zephyr mouse display driver.
This function should be called prior to exiting any program
that previously called MOUSEENTER.
SEE ALSO
MOUSEENTER, MOUSEHIDE, MOUSESHOW
EXAMPLE
/*
* enable,show mouse, then disable it
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mousecursordefault();
mouseenter();
mouseshow();
getch();
mousehide();
mouseexit();
videomodeset(vmode);
exit(0);
106
}
107
MOUSEHIDE
PROTOTYPE
extern void far mousehide (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEHIDE turns off the mouse display driver and removes the
cursor from the display. It is recommended to hide the
mouse any time something will be drawn in its general
vicinity. Note, however, that although the cursor is not
visible, all other mouse abilities remain active.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSESHOW
EXAMPLE
/*
* enable,show mouse,hide mouse
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mousecursordefault();
mouseenter();
mouseshow();
getch();
mousehide();
getch();
mouseexit();
videomodeset(vmode);
108
exit(0);
}
109
MOUSEINFO
PROTOTYPE
extern void far mouseinfo (int far *drvmajorver, int far
*drvminorver, int far *mousetype, int far *irqnumber)
INPUT
no input parameters
OUTPUT
drvmajorver - Microsoft compatible mouse driver major
version number
drvminorver - Microsoft compatible mouse driver minor
version number
mousetype - type of mouse installed
irqnumber - interrupt used by the mouse
USAGE
MOUSEINFO returns information about the mouse and its
installed driver. The driver must be Microsoft compatible.
This information can be used to determine whether the mouse
functions in this library will operate correctly. For
proper operation the driver version number must be greater
than 1.00. Irqnumber gives the interrupt number of the
mouse. Mousetype returns information about the type of
hardware installed according to the following table:
0 = unknown type
1 = bus mouse
2 = serial mouse
3 = Inport mouse
4 = PS/2 mouse
5 = HP mouse
SEE ALSO
WHICHMOUSE
EXAMPLE
/*
* id any installed mouse
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
110
int mjv, mnv, tp, i, mouse;
char buf[100];
mouse = whichmouse();
if (mouse > 0) {
mouseinfo(&mjv, &mnv, &tp, &i);
switch (tp) {
case 1:
sprintf(buf,"bus mouse");
break;
case 2:
sprintf(buf,"serial mouse");
break;
case 3:
sprintf(buf,"Inport mouse");
break;
case 4:
sprintf(buf,"PS/2 mouse");
break;
case 5:
sprintf(buf,"HP mouse");
break;
default:
sprintf(buf,"unknown type");
}
printf("Microsoft compatible %s detected with %d
buttons on IRQ %d.\n", &buf, mouse, i);
printf("Software driver version is %d.%d (Microsoft
equivalent version).\n\n", mjv, mnv);
} else
printf("No Microsoft compatible mouse detected.\n\n");
}
111
MOUSELOCSET
PROTOTYPE
extern void far mouselocset (int xloc, int yloc)
INPUT
x, y - location on screen
OUTPUT
no value returned
USAGE
MOUSELOCSET moves the mouse cursor the location on the
screen specified by x, y. If either x or y is outside of
the currently permitted mouse range, it is set to the
closest border. The currently permitted mouse range is the
current screen resolution or the last called MOUSERANGESET.
SEE ALSO
MOUSEENTER, MOUSERANGESET
EXAMPLE
/*
* enable,show mouse then move it to the origin
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
res640();
mousecursordefault();
mouseenter();
mouseshow();
getch();
mouselocset(0,0);
getch();
mousehide();
mouseexit();
videomodeset(vmode);
112
exit(0);
}
113
MOUSERANGESET
PROTOTYPE
extern void far mouserangeset (int x1, int y1, int x2, int
y2)
INPUT
x1, y1 - location on screen of top, left corner of range
x2, y2 - location on screen of bottom, right corner of range
OUTPUT
no value returned
USAGE
MOUSERANGESET defines a permissible range on the screen for
mouse movement. The mouse is automatically positioned in
the center of this range.
SEE ALSO
MOUSELOCSET, MOUSESTATUS
EXAMPLE
/*
* enable,show and set a range for the mouse
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
if ( !res640() )
exit(1);
mouseenter();
drwbox(1,10,100,100,539,379);
mouserangeset(100,100,539,379);
mouseshow();
getch();
mousehide();
114
mouseexit();
videomodeset(vmode);
exit(0);
}
115
MOUSERESTORESTATE
PROTOTYPE
extern void far mouserestorestate (byte far *mousebuf)
INPUT
mousebuf - byte pointer to buffer holding complete mouse
status information
OUTPUT
no value returned
USAGE
MOUSERESTORESTATE completely restores a previously saved
mouse status as contained in mousebuf. The mouse status
must have been already stored in mousebuf by MOUSESAVESTATE.
SEE ALSO
MOUSESAVESTATE, MOUSESTORAGESIZE
EXAMPLE
/*
* save the mouse driver state,shell out to DOS, restore the
driver state
*/
#include <stdlib.h>
#include <conio.h>
#include <process.h>
#include "svgacc.h"
void main(void)
{
int rt, bufsiz;
byte *mousedriverdata;
char cmdcom[]="C:\COMMAND.COM";
char *args[1];
if ( !whichmouse())
exit(1);
bufsiz=mousestoragesize();
mousedriverdata = (byte *)malloc(bufsiz);
mousesavestate(mousedriverdata);
printf("* Type Exit To Return To Program *");
args[0]=NULL;
rt=spawnv(P_WAIT,cmdcom,args);
mouserestorestate(mousedriverdata);
printf("mouse driver data restored...");
116
exit(0);
}
117
MOUSESAVESTATE
PROTOTYPE
extern void far mousesavestate (byte far *mousebuf)
INPUT
no input parameters
OUTPUT
no value returned
mousebuf - buffer holding complete mouse status information
USAGE
MOUSESAVESTATE saves the complete mouse status in mousebuf.
The size of mousebuf in bytes is defined by MOUSESTORAGESIZE
which should called first.
SEE ALSO
MOUSERESTORESTATE, MOUSESTORAGESIZE
EXAMPLE
See MOUSERESTORESTATE
118
MOUSESENSSET
PROTOTYPE
extern void far mousesensset (int xsens, int ysens, int
dblspdthresh)
INPUT
xsens = number of mickeys per 8 pixels horizontally (default
= 8 mickeys per 8 pixels)
ysens = number of mickeys per 8 pixels vertically (default =
16 mickeys per 8 pixels)
dblspdthresh=number of mickeys per second at which speed is
doubled (default = 64)
OUTPUT
no value returned
USAGE
MOUSESENSSET defines the relationship between mouse movement
and cursor movement on the screen. A mickey is defined as
1/200th of an inch. The ratio between mickeys and pixels is
specified by xsens and ysens in the horizontal and vertical
directions respectively. When the mouse movement is faster
than DblSpdThresh in mickeys per second, the speed is
doubled. The default values are assigned whenever
MOUSEENTER or MOUSEEXIT are called.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSESTATUS
EXAMPLE
/*
* enable,show the mouse and make it very sensitive
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !whichmouse())
exit(1);
119
res640();
mousecursordefault();
mouseenter();
mouseshow();
mousesensset(100,100);
getch();
mousehide();
mouseexit();
videomodeset(vmode);
exit(0);
}
120
MOUSESHOW
PROTOTYPE
extern void far mouseshow (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSESHOW enables the mouse display driver and places the
cursor on the screen. The cursor is only updated when the
mouse is moved. Therefore, it is recommended to hide the
cursor when drawing on the screen to avoid unexpected
results.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSEHIDE
EXAMPLE
See MOUSEHIDE
121
MOUSESTATUS
PROTOTYPE
extern void far mousestatus (int far *x, int far *y, int far
*mbuts)
INPUT
no input parameters
OUTPUT
x, y - mouse position on screen
mbuts - status of mouse buttons
USAGE
MOUSESTATUS returns the current status of the mouse position
and buttons. The position is returned in x, y. The
buttons' status is held in mbuts. The left button is held
in bit zero, right button in bit one and center button - for
three button mice - in bit two. Button status is most
easily checked with a bitwise AND of mbuts and the desired
bit.
SEE ALSO
MOUSERANGESET, MOUSESENSSET
EXAMPLE
/* enable,show mouse & display status */
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, x, y, mbuts;
char buf[100];
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
if ( !whichmouse())
exit(1);
res640();
mouseenter();
mouseshow();
while(!kbhit()) {
mousestatus(&x,&y,&mbuts);
sprintf(buf,"X= %4d Y= %4d LB= %1d CB= %1d RB=
%1d\0",x,y,(mbuts & 1),(mbuts & 2),(mbuts & 4));
122
drwstring(1,15,8,buf,10,32);
}
mousehide();
mouseexit();
videomodeset(vmode);
}
123
MOUSESTORAGESIZE
PROTOTYPE
extern int far mousestoragesize (void)
INPUT
no input parameters
OUTPUT
MOUSESTORAGESIZE returns the size of buffer in bytes to
store complete mouse status
USAGE
MOUSESTORAGESIZE determines the proper size buffer to hold
the complete mouse status information. This buffer should
be allocated before calling MOUSESAVESTATE.
SEE ALSO
MOUSERESTORESTATE, MOUSESAVESTATE
EXAMPLE
/*
* return the size in bytes need to save the mouse driver
status
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int bufsiz;
char buf[50];
if ( !whichmouse())
exit(1);
bufsiz=mousestoragesize();
sprintf(buf,"%d bytes are required to save mouse driver
status...",bufsiz);
printf("%s", &buf);
exit(0);
}
124
OVERSCANSET
PROTOTYPE
extern void far overscanset (int colr)
INPUT
colr - index to color in current palette
OUTPUT
no value returned
USAGE
OVERSCANSET sets the overscan region to the specified color.
The overscan region is the area between the usable pixel
area and the region not scanned by the monitor. Normally,
the overscan is color zero which is defined as black the
majority of the time. The overscan color is reset to zero
anytime a RES### function is called.
Note: OVERSCANSET always works in the 320x200 resolution.
In the higher resolutions on many common SVGA cards this
function is ignored. Instead, the card always assigns the
overscan region to color zero. Therefore, it is recommended
to not use OVERSCANSET, but assign color zero as needed.
EXAMPLE
/*
* set the overscan color to green
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
res320();
overscanset(10);
getch();
videomodeset(vmode);
exit(0);
}
125
PAGEACTIVE
PROTOTYPE
extern int far pageactive (int page)
INPUT
page - number of page to make active
OUTPUT
PAGEACTIVE returns a 1 if successful, 0 if unsuccessful.
USAGE
PAGEACTIVE sets the active page as specified by page. It
works by creating an offset to be added when any bank
switching is performed. This function does not affect the
actual display. A page is defined as the number of 64K
blocks necessary to contain the current screen resolution.
For example, 640x480 requires 307,200 bytes which is a
little more than 4.5 64K blocks. One page in this
resolution will be 5 banks.
PAGEACTIVE does not work in 320x200 mode since this mode
uses no bank switching.
SEE ALSO
FILLPAGE, PAGEDISPLAY
EXAMPLE
/*
* Show pageactive (video card needs 1meg to show pages in
640x480x256)
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode,er;
char text[]="press a key...";
char buf[20];
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 1024)
exit(1);
126
if ( !res640() )
exit(1);
/* make sure video card supports page flipping */
if ( !pagedisplay(0,0,0) ) {
videomodeset(vmode);
exit(1);
}
er = pageactive(0);
fillpage(0);
drwstring(1,10,0,text,0,300);
sprintf(buf,"Page 0");
drwstring(1,10,0,buf,0,0);
er = pageactive(1);
fillpage(0);
drwstring(1,12,0,text,0,300);
sprintf(buf,"Page 1");
drwstring(1,12,0,buf,0,20);
er = pageactive(2);
fillpage(0);
drwstring(1,13,0,text,0,300);
sprintf(buf,"Page 2");
drwstring(1,13,0,buf,0,40);
er = pageactive(0);
er = pagedisplay(0,0,0);
getch();
er = pagedisplay(0,0,1);
getch();
er = pagedisplay(0,0,2);
getch();
videomodeset(vmode);
exit(0);
}
127
PAGEDISPLAY
PROTOTYPE
extern int far pagedisplay (int x, int y, int page)
INPUT
x, y - coordinate to place at top, left of display
page - number of page to make active
OUTPUT
PAGEDISPLAY returns a 1 if successful, 0 if unsuccessful.
USAGE
PAGEDISPLAY tells the video card where in video memory to
begin the display. This display offset is calculated from
the specified page, x and y. This is done by multiplying y
times the width of the current resolution, adding x and then
adding the appropriate number of 64K blocks for page. X, y
and page must all be positive numbers, but are otherwise not
restricted. The display will wrap if the values are
abnormally large. Wrapping will happen from side to side as
well as from top of memory to bottom of memory.
PAGEDISPLAY does not work in 320x200 mode since this mode
uses no bank switching. In addition, older models of some
SVGA cards operating in native mode do not support paging.
In this library these cards are: Acumos, Ahead version A,
Everex and Genoa. To ensure compatibility, a program should
make a call similar to:
if ( !pagedisplay(0,0,0) )
printf("PAGING NOT SUPPORTED\n");
Note: SVGA cards by ATI Technologies appear to ignore bit 4
(counting from 0 to 19) in its linear addressing mode and
assume it is zero. Therefore, bit 4 of the x parameter will
be ignored by ATI chipsets.
SEE ALSO
FILLPAGE, PAGEACTIVE
EXAMPLE
See PAGEACTIVE
128
PALCHGAUTO
PROTOTYPE
extern void far palchgauto (RGB far *pal, RGB far *newpal,
int firstcolr, int lastcolr, int speed)
INPUT
pal - initial palette
newpal - new palette
firstcolr - index into palette where change will begin
lastcolr - index into palette where change will end
speed - speed of change
OUTPUT
no value returned
USAGE
PALCHGAUTO smoothly fades the colors between firstcolr and
lastcolr from the palette pal to newpal. The speed of the
fade is set by speed which is percentage change between each
step of the fade. Only values between 1 and 128 are valid
where 1 represents a one percent change between steps and
128 (80 hex) represents fifty percent change between steps.
A speed of 128 would then have only two steps. A speed
outside of the valid range causes the function to
immediately return without making any changes. The time
required to accomplish the entire fade is approximately
equal to 0.033 seconds times 256 divided by speed.
PALCHGAUTO does not modify either pal or newpal.
SEE ALSO
PALCHGSTEP, PALDIMSTEP, PALIOAUTO
EXAMPLE
/*
* autofade from one palette to another and back again
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, colr, y, i, index;
PaletteData orgpal, newpal;
vmode = videomodeget();
129
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
palget(orgpal,0,255);
for (index=0;index<256;index++) {
newpal[index].r = index / 4;
newpal[index].g = index / 4;
newpal[index].b = index / 4;
}
colr = 0;
for (y=0;y<480;y++) {
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
palchgauto(orgpal,newpal,0,255,2);
palchgauto(newpal,orgpal,0,255,2);
getch();
videomodeset(vmode);
exit(0);
}
130
PALCHGSTEP
PROTOTYPE
extern void far palchgstep (RGB far *pal, RGB far *newpal,
int firstcolr, int lastcolr, int percent)
INPUT
pal - initial palette
newpal - new palette
firstcolr - index into palette where change will begin
lastcolr - index into palette where change will end
percent - percent step from current palette to new palette
OUTPUT
no value returned
USAGE
PALCHGSTEP changes the palette colors between firstcolr and
lastcolr by percent from pal to newpal. This function works
very much like PALCHGAUTO except it only takes a single step
and returns. The step taken is a percentage specified by
Percent where 256 (100 hex) is a 100 percent change. The
valid range for Percent is 0 to 256. Values beyond this
range cause the function to immediately return without
making any changes. A loop from 4 to 256 by fours using
PALCHGSTEP would have similar results as PALCHGAUTO with a
speed of 4. Neither pal, nor newpal are modified.
SEE ALSO
PALCHGAUTO, PALDIMSTEP, PALIOAUTO
EXAMPLE
/*
* step fade from one palette to another and back again
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, colr, y, i, index;
PaletteData orgpal, newpal;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
131
if ( whichmem() < 512)
exit(1);
res640();
palget(orgpal,0,255);
for (index=0;index<256;index++)
{
newpal[index].r = index / 4;
newpal[index].g = index / 4;
newpal[index].b = index / 4;
}
colr = 0;
for (y=0;y<480;y++)
{
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
for (index=0;index<256;index++)
{
palchgstep(orgpal,newpal,0,255,index);
}
for (index=256;index>=-1;index--)
{
palchgstep(orgpal,newpal,0,255,index);
}
getch();
videomodeset(vmode);
exit(0);
}
132
PALCOPY
PROTOTYPE
extern void far palcopy (RGB far *srcpal, RGB far *destpal,
int firstcolr, int lastcolr)
INPUT
srcpal - source palette
firstcolr - index into palette where copy will begin
lastcolr - index into palette where copy will end
OUTPUT
no value returned
destpal - copy of srcpal
USAGE
PALCOPY quickly copies a source palette into a second
palette array. Destpal must be previously allocated. A
portion of a palette may be copied by specifying first and
last colors. If firstcolr is greater than lastcolr, no copy
will occur.
SEE ALSO
BYTECOPY
EXAMPLE
/*
* create a color palette(grayscale) and copy it to a
palette
* of a different name
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode,colr,y,i,index;
PaletteData pal, newpal;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
133
for (index=0;index<256;index++) {
pal[index].r = index / 4;
pal[index].g = index / 4;
pal[index].b = index / 4;
}
colr = 0;
palcopy(pal,newpal,0,255);
for (y=0;y<480;y++) {
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
palset(newpal,0,255);
getch();
videomodeset(vmode);
exit(0);
}
134
PALDIMSTEP
PROTOTYPE
extern void far paldimstep (RGB far *pal, int firstcolr, int
lastcolr, int percent)
INPUT
pal - initial palette
firstcolr - index into palette where dim will begin
lastcolr - index into palette where dim will end
percent - percent step from current palette to black
OUTPUT
no value returned
USAGE
PALDIMSTEP fades the specified palette to black by the given
percentage between firstcolr and lastcolr. The percentage
step from pal to black is specified by percent where 256
(100 hex) is full black. The valid range for Percent is 0
to 256. Values beyond this range cause the function to
immediately return without making any changes. pal is not
modified.
SEE ALSO
PALCHGAUTO, PALCHGSTEP, PALIOAUTO
EXAMPLE
/*
* step dim from a palette to black and back again
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int colr;
int y;
int i;
int index;
PaletteData orgpal;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
135
if ( whichmem() < 512)
exit(1);
res640();
palget(orgpal,0,255);
colr = 0;
for (y=0;y<480;y++)
{
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
for (index=0;index<256;index++)
{
paldimstep(orgpal,0,255,index);
}
for (index=256;index>=-1;index--)
{
paldimstep(orgpal,0,255,index);
}
getch();
videomodeset(vmode);
exit(0);
}
136
PALGET
PROTOTYPE
extern void far palget (RGB far *pal, int firstcolr, int
lastcolr)
INPUT
firstcolr - index into palette where get will begin
lastcolr - index into palette where get will end
OUTPUT
pal - copy of the current palette in the specified range
USAGE
PALGET returns in pal the colors from the current palette
between firstcolr and lastcolr. Only colors in the
specified range are returned and all others in pal are
unchanged. Pal must be 768 bytes in length despite the
number of colors retrieved.
SEE ALSO
PALROTATE, PALSET
EXAMPLE
See PALCHGAUTO
137
PALIOAUTO
PROTOTYPE
extern void far palioauto (RGB far *pal, int firstcolr, int
lastcolr, int speed)
INPUT
pal - initial palette
firstcolr - index into palette where fade will begin
lastcolr - index into palette where fade will end
speed - speed of fade
OUTPUT
no value returned
USAGE
PALIOAUTO smoothly fades the colors between firstcolr and
lastcolr of pal to or from solid black. The speed of the
fade is set by speed which is the percentage change between
each step of the fade. A positive speed corresponds to
fading from pal to black and a negative speed fades from
black to Pal. Only values between -128 and +128 are valid
where 1 represents a one percent change between steps and
128 (80 hex) represents fifty percent change between steps.
A speed of 128 would then have only two steps. A speed
outside of the valid range causes the function to
immediately return without making any changes. The time
required to accomplish the entire fade is approximately
equal to 0.033 seconds times 256 divided by speed.
PALIOAUTO does not modify pal.
SEE ALSO
PALCHGAUTO, PALCHGSTEP, PALDIMSTEP
EXAMPLE
/*
* autofade a palette to black and back again
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, colr, y;
PaletteData orgpal;
138
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
colr = 0;
palget(orgpal,0,255);
for (y=0;y<480;y++) {
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
palioauto(orgpal,0,255,-2);
palioauto(orgpal,0,255,2);
getch();
videomodeset(vmode);
exit(0);
}
139
PALROTATE
PROTOTYPE
extern void far palrotate (RGB far *pal, int firstcolr, int
lastcolr, int shift)
INPUT
pal - PaletteData pointer to current palette
firstcolr - index into palette where shift will begin
lastcolr - index into palette where shift will end
shift - number of locations to shift colors
OUTPUT
no value returned
USAGE
PALROTATE shifts the colors in pal between firstcolr and
lastcolr by a given number of locations and sets this new
palette. The number of locations the colors are moved is
specified by shift which is between 1 and 256. Pal is not
modified by PALROTATE.
SEE ALSO
PALGET, PALSET
EXAMPLE
/*
* rotate a few palette entries around
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, colr, y, i, index;
PaletteData orgpal;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
colr = 0;
palget(orgpal,0,255);
for (y=0;y<480;y++) {
140
drwline(1,colr++,0,y,639,y);
if (colr>255)
colr = 0;
}
for (i=0;i<200;i++) {
palrotate(orgpal,1,127,1);
palget(orgpal,0,255);
}
getch();
videomodeset(vmode);
exit(0);
}
141
PALSET
PROTOTYPE
extern void far palset (RGB far *pal, int firstcolr, int
lastcolr)
INPUT
pal - palette to set
firstcolr - index into palette where set will begin
lastcolr - index into palette where set will end
OUTPUT
no value returned
USAGE
PALSET sets the specified range of colors in the current
palette with the corresponding range in the palette pal.
SEE ALSO
PALGET
EXAMPLE
See PALCOPY
142
RES320
PROTOTYPE
extern int far res320 (void)
INPUT
no input parameters
OUTPUT
RES320 always returns a 1.
USAGE
RES320 sets video mode 0x13 which is the industry standard
320x200 graphics mode with 256 colors. This function can be
called without calling WHICHVGA first as this function
requires only that a VGA card is present, not a Super VGA
card. If a VGA is not present, the system may crash.
SEE ALSO
RES640, RES640L, RES800, RES1024, RES1280, WHICHVGA
EXAMPLE
/*
* set video mode to 320x200x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit();
res320();
drwstring(1,7,0,"this is the 320x200x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
}
143
RES640
PROTOTYPE
extern int far res640 (void)
INPUT
no input parameters
OUTPUT
RES640 returns 1 if successful, 0 otherwise.
USAGE
RES640 sets the video mode to 640x480 graphics mode with 256
colors. This function requires that a Super VGA card with
at least 512K of video memory be present. Also, WHICHVGA
must be called first or the function will fail without
changing the video mode. If the video card does not have
sufficient memory, RES640 will return without changing the
video mode.
SEE ALSO
RES320, RES640L, RES800, RES1024, RES1280, WHICHVGA
EXAMPLE
/*
* set video mode to 640x480x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512 )
exit(1);
res640();
drwstring(1,7,0,"this is the 640x480x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
}
144
RES640L
PROTOTYPE
extern int far res640l (void)
INPUT
no input parameters
OUTPUT
RES640L returns 1 if successful, 0 otherwise.
USAGE
RES640L sets the video mode to 640x400 graphics mode with
256 colors. This function requires that a Super VGA card
with at least 256K of video memory be present. Also,
WHICHVGA must be called first or the function will fail
without changing the video mode. If the video card does not
have sufficient memory, RES640L will return without changing
the video mode.
Note: The 640x400 is an uncommon resolution. Many SVGA
cards do not support this mode.
SEE ALSO
RES320, RES640, RES800, RES1024, RES1280, WHICHVGA
EXAMPLE
/*
* set video mode to 640x400x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
res640l();
drwstring(1,7,0,"this is the 640x400x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
145
}
146
RES800
PROTOTYPE
extern int far res800 (void)
INPUT
no input parameters
OUTPUT
RES800 returns 1 if successful, 0 otherwise.
USAGE
RES800 sets the video mode to 800x600 graphics mode with 256
colors. This function requires that a Super VGA card with
at least 512K of video memory be present. Also, WHICHVGA
must be called first or the function will fail without
changing the video mode. If the video card does not have
sufficient memory, RES800 will return without changing the
video mode.
SEE ALSO
RES320, RES640, RES640L, RES1024, RES1280, WHICHVGA
EXAMPLE
/*
* set video mode to 800x600x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512 )
exit(1);
res800();
drwstring(1,7,0,"this is the 800x600x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
}
147
RES1024
PROTOTYPE
extern int far res1024 (void)
INPUT
no input parameters
OUTPUT
RES1024 returns 1 if successful, 0 otherwise.
USAGE
RES1024 sets the video mode to 1024x768 graphics mode with
256 colors. This function requires that a Super VGA card
with at least 1 Megabyte of video memory be present. Also,
WHICHVGA must be called first or the function will fail
without changing the video mode. If the video card does not
have sufficient memory, RES1024 will return without changing
the video mode.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1280, WHICHVGA
EXAMPLE
/*
* set video mode to 1024x768x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 1024 )
exit(1);
res1024();
drwstring(1,7,0,"this is the 1024x768x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
}
148
RES1280
PROTOTYPE
extern int far res1280 (void)
INPUT
no input parameters
OUTPUT
RES1280 returns 1 if successful, 0 otherwise.
USAGE
RES1280 sets the video mode to 1280x1024 graphics mode with
256 colors. This function requires that a Super VGA card
with at least 2 Megabytes of video memory be present. Also,
WHICHVGA must be called first or the function will fail
without changing the video mode. If the video card does not
have sufficient memory, RES1280 will return without changing
the video mode.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, WHICHVGA
EXAMPLE
/*
* set video mode to 1280x1024x256
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 2048 )
exit(1);
res1024();
drwstring(1,7,0,"this is the 1280x1024x256 video
mode...",0,0);
getch();
videomodeset(vmode);
exit(0);
}
149
RESTEXT
PROTOTYPE
extern int far restext (void)
INPUT
no input parameters
OUTPUT
RESTEXT always returns a 1.
USAGE
RESTEXT sets video mode three which is the industry standard
80x25 text mode.
SEE ALSO
VIDEOMODEGET, VIDEOMODESET
EXAMPLE
/*
* set video mode to standard DOS text mode 3
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !restext() )
exit(1);
printf("this is the text video mode (DOS video mode
3)...");
getch();
videomodeset(vmode);
exit(0);
}
150
SCROLLDN
PROTOTYPE
extern void far scrolldn (int x1, int y1, int x2, int y2,
int num, int colr)
INPUT
x1, y1 - top left corner of block
x2, y2 - bottom right corner of block
num - number of pixels to shift
colr - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLDN shifts the contents of the box described by (x1,
y1) - (x2, y2) down by the number of pixels specified by
num. The empty pixels created at the top of the box are
filled with colr. The pixels that are shifted out of the
box are lost. SCROLLDN enforces x2x1 and y2 y1. When
placed within a loop, SCROLLDN will create a scrolling
effect.
SEE ALSO
SCROLLLT, SCROLLRT, SCROLLUP
EXAMPLE
/*
* scroll some text down
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, i;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwbox (1,10,0,0,100,100);
drwstring(1,7,0,"text text",20,43);
for(i=0;i<40;i++)
{
151
scrolldn(1,1,99,99,1,0);
sdelay(2);
}
getch();
videomodeset(vmode);
}
152
SCROLLLT
PROTOTYPE
extern void far scrolllt (int x1, int y1, int x2, int y2,
int num, int colr)
INPUT
x1, y1 - top left corner of block
x2, y2 - bottom right corner of block
num - number of pixels to shift
colr - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLLT shifts the contents of the box described by (x1,
y1) - (x2, y2) down by the number of pixels specified by
num. The empty pixels created at the right of the box are
filled with colr. The pixels that are shifted out of the
box are lost. SCROLLLT enforces x2x1 and y2 y1. When
placed within a loop, SCROLLRT will create a scrolling
effect.
SEE ALSO
SCROLLDN, SCROLLRT, SCROLLUP
EXAMPLE
/*
* scroll some text left
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, i;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwbox (1,10,0,0,100,100);
drwstring(1,7,0,"text text",20,43);
for(i=0;i<40;i++)
{
153
scrolllt(1,1,99,99,1,0);
sdelay(2);
}
getch();
videomodeset(vmode);
}
154
SCROLLRT
PROTOTYPE
extern void far scrollrt (int x1, int y1, int x2, int y2,
int num, int colr)
INPUT
x1, y1 - top left corner of block
x2, y2 - bottom right corner of block
num - number of pixels to shift
colr - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLRT shifts the contents of the box described by (x1,
y1) - (x2, y2) down by the number of pixels specified by
num. The empty pixels created at the left of the box are
filled with colr. The pixels that are shifted out of the
box are lost. SCROLLRT enforces x2x1 and y2 y1. When
placed within a loop, SCROLLRT will create a scrolling
effect.
SEE ALSO
SCROLLDN, SCROLLLT, SCROLLUP
EXAMPLE
/*
* scroll some text right
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, i;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwbox (1,10,0,0,100,100);
drwstring(1,7,0,"text text",20,43);
for(i=0;i<40;i++)
{
155
scrollrt(1,1,99,99,1,0);
sdelay(2);
}
getch();
videomodeset(vmode);
}
156
SCROLLUP
PROTOTYPE
extern void far scrollup (int x1, int y1, int x2, int y2,
int num, int colr)
INPUT
x1, y1 - top left corner of block
x2, y2 - bottom right corner of block
num - number of pixels to shift
colr - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLUP shifts the contents of the box described by (x1,
y1) - (x2, y2) down by the number of pixels specified by
num. The empty pixels created at the bottom of the box are
filled with colr. The pixels that are shifted out of the
box are lost. SCROLLUP enforces x2x1 and y2 y1. When
placed within a loop, SCROLLUP will create a scrolling
effect.
SEE ALSO
SCROLLDN, SCROLLLT, SCROLLRT
EXAMPLE
/*
* scroll some text up
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, i;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwbox (1,10,0,0,100,100);
drwstring(1,7,0,"text text",20,43);
for(i=0;i<40;i++)
{
157
scrollup(1,1,99,99,1,0);
sdelay(2);
}
getch();
videomodeset(vmode);
}
158
SDELAY
PROTOTYPE
extern void far sdelay (int count)
INPUT
count - number of vertical syncs to wait
OUTPUT
no value returned
USAGE
SDELAY pauses execution of the program for a period of time
specified by count. This delay remains approximately
constant on all machines by using the vertical sync timer of
the VGA graphics card which is about 60 - 70 Hz.
EXAMPLE
/*
* make a delay of about 3 seconds long
*/
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include "svgacc.h"
void main(void)
{
time_t starttime;
time_t endtime;
printf("ok...stating delay...should be about 3
seconds...");
time( &starttime);
sdelay(195);
time( &endtime);
printf("total time was: %d seconds...", endtime-
starttime);
exit(0);
}
159
SETCARD
PROTOTYPE
extern void far setcard (VGAChipset chip, int mem)
INPUT
chip - code for SVGA chip type
mem - amount of video memory installed
OUTPUT
no value returned
USAGE
WARNING: USING SETCARD IMPROPERLY MAY CAUSE A SYSTEM
FAILURE OR DAMAGE.
SETCARD sets the card type and installed video memory. It
can be used instead of the WHICHVGA function. However,
specifying an incorrect chip type or installed video memory
may cause unpredictable results not excluding damage to the
SVGA card and/or monitor. Extreme caution is advised when
using this function. It is recommended that this function
only be used when it is suspected that the identification
process in WHICHVGA failed. Be absolutely certain that the
chip type specified is the actual chip type installed in the
computer. Mem should be a value of 256, 512 or 1024
representing the kilobytes of video memory installed. Use
the following table to identify chip types:
1 Acumos AVGA2/3 SuperVGA
2 ATI Technologies 18/28/38/68800
SuperVGA
3 Ahead V5000 ver A SuperVGA
4 Ahead V5000 ver B SuperVGA
5 Chips and Technologies 82C45x SuperVGA
6 Cirrus Logic CL-GD 5xx, 6xx, 28xx,
54xx, 62xx SuperVGA
7 Everex Micro Enhancer Ev236/6xx
SuperVGA
8 Genoa 61/62/63/64/6600 SuperVGA
9 NCR 77C21/22/22E/22E+ SuperVGA
10 Oak Technologies OTI-037C/067/077/087
SuperVGA
11 Paradise/Western Digital PVGA1A,
WD90C00/1x/2x/3x SuperVGA
12 Realtek RT3106 SuperVGA
13 Trident 8800CS, 8900B/C/CL/CX, 90x0
SuperVGA
14 Tseng Labs ET3000-AX/BX/BP SuperVGA
15 Tseng Labs ET4000/W32/W32I SuperVGA
16 VESA compatible SuperVGA
160
17 Video 7 HT-208/16 SuperVGA
18 Avance Logic AL2101 SuperVGA
19 MXIC MX68000/10 SuperVGA
20 Primus P2000 SuperVGA
SEE ALSO
WHICHVGA
EXAMPLE
/*
!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WAR
NING! */
/* */
/* USE THE "SETCARD" FUNCTION CAREFULLY. IT WORKS AROUND
"WHICHVGA". */
/* IMPROPER USE (I.E. SETTING THE CARD ID AND MEMORY TO
SOMETHING */
/* THAT IS NOT VALID) MIGHT DAMAGE YOUR VIDEO CARD/VIDEO
MONITOR OR */
/* CAUSE UNPREDICTABLE RESULTS. IT IS PROVIDED AS A METHOD
TO FIND*/
/* FAULTS IN THE VIDEO CARD/CHIP ID PROCESS.
*/
/* */
/*
!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WAR
NING! */
161
SETVIEW
PROTOTYPE
extern void far setview (int x1, int y1, int x2, int y2)
INPUT
x1, y1 - top, left corner of view port
x2, y2 - bottom, right corner of view port
OUTPUT
no value returned
USAGE
SETVIEW defines a viewport for clipping output on the
screen. Nothing can be drawn outside of the currently
defined viewport. The RES### functions set the viewport to
the full screen. The restrictions on X1, Y1, X2 and Y2 are
as follows:
0 X1 < X2 (screen width)
0 Y1 < Y2 (32767, effectively unbounded)
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RES1280
EXAMPLE
/*
* draws a lines clipped to a view port
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
#define randnum(size) (rand() % (int)(size))
void main(void)
{
int vmode, i, x1, y1, x2, y2;
vmode = videomodeget();
if ( !whichvga() || (whichmem() < 512))
exit(1);
res640();
drwbox(1,15,101,101,538,378);
setview(101,101,538,378);
for(i=0;i<300;i++) {
x1 = randnum(640);
y1 = randnum(480);
162
x2 = randnum(640);
y2 = randnum(480);
drwline(1,10,x1,y1,x2,y2);
}
getch();
videomodeset(vmode);
exit(0);
}
163
SPRITECOLLDETECT
PROTOTYPE
extern int far spritecolldetect (int transcolr, int x1, int
y1, int x2, int y2, RasterBlock far *sprite1, RasterBlock
far *sprite2)
INPUT
transcolr - index to color in current palette
x1, y1 - location of top, left corner of sprite number 1
x2, y2 - location of top, left corner of sprite number 2
sprite1 - sprite number 1
sprite2 - sprite number 2
OUTPUT
SPRITECOLLDETECT returns the collision status of the two
sprites.
USAGE
SPRITECOLLDETECT is used in sprite graphics or animation to
report the collision status between two sprites. Sprite1
contains the first sprite which should have been previously
defined by BLKGET or similar function. Sprite2, likewise,
contains the second sprite. The top, left corner of the
first and second sprites' locations are specified by x1, y1
and x2, y2, respectively.
SPRITECOLLDETECT will return a zero if the sprites are not
colliding and the blocks are not overlapping. The return
will be one if the blocks overlap, but the sprites are not
colliding. A return value of two indicates that the sprites
have at least one overlapping pixel and are, therefore,
colliding.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITEGAP, SPRITEGET,
SPRITEPUT
EXAMPLE
/*
* shows how spritecolldetect works
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
164
{
int vmode, ret, i, x1, y1, x2, y2;
char text[70];
RasterBlock *sprite1data, *sprite2data;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
res320();
x1 = 0;
y1 = 0;
x2 = 48;
y2 = 48;
drwline(1,8,x1,y1,x2,y1);
drwline(1,8,x2,y1,x2,y2);
drwline(1,8,x2,y2,x1,y2);
drwline(1,8,x1,y2,x1,y1);
fillarea(x1+1,y1+1,8,8);
drwellipse(1,10,((x2-x1)/2+x1),((y2-y1)/2+y1),(x2-
x1)/2,(y2-y1)/2);
sprite1data = (RasterBlock *)malloc((x2-x1+1)*(y2-
y1+1)+4);
blkget(x1,y1,x2,y2,sprite1data);
blkput(2,x1,y1,sprite1data);
x1 = 0;
y1 = 0;
x2 = 24;
y2 = 24;
drwline(1,8,x1,y1,x2,y1);
drwline(1,8,x2,y1,x2,y2);
drwline(1,8,x2,y2,x1,y2);
drwline(1,8,x1,y2,x1,y1);
fillarea(x1+1,y1+1,8,8);
drwline(1,10,x1,y1,x2,y2);
drwline(1,10,x2,y1,x1,y2);
sprite2data = (RasterBlock *)malloc((x2-x1+1)*(y2-
y1+1)+4);
blkget(x1,y1,x2,y2,sprite2data);
blkput(2,x1,y1,sprite2data);
x1=90;
y1=90;
blkput(2,x1,y1,sprite1data);
for(i=30;i<150;i++)
{
blkput(2,i,i,sprite2data);
ret =
spritecolldetect(8,x1,y1,i,i,sprite1data,sprite2data);
sprintf(text,"the return value is: %d",ret);
drwstring(1,7,0,text,0,0);
getch();
blkput(2,i,i,sprite2data);
}
videomodeset(vmode);
165
exit(0);
}
166
SPRITEGAP
PROTOTYPE
extern void far spritegap (int transcolr, int x, int y,
RasterBlock far *sprite, RasterBlock far *spritebkgnd)
INPUT
transcolr - index to color in current palette
x, y - top, left corner of block
sprite- the sprite to place on screen
OUTPUT
no value returned
spritebkgnd - sprite background
USAGE
SPRITEGAP ("Sprite-Get-And-Put") is used in sprite graphics
or animation to retrieve a sprite's background and then
display the sprite. Sprite contains the sprite which should
have been previously defined by BLKGET or similar function
such as GETLASTSTRING. Transcolr is the transparent colr
assumed in sprite. Spritebkgnd, a pointer to a RasterBlock
structure the same size as the sprite, will receive the
sprite's background. The top, left corner of the sprite's
location is specified by x, y.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGET,
SPRITEPUT
EXAMPLE
/*
* Show spritegap
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int i, j, colr, xinc, yinc, x1, y1, x2, y2, cnt, cntx,
cnty, rot;
RasterBlock *gfxblk, *gfxblk2, *spritebkgnd;
vmode = videomodeget();
167
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
xinc = maxx/20;
yinc = maxy/20;
x1 = maxx/2-xinc;
y1 = maxy/2-yinc;
x2 = maxx/2+xinc;
y2 = maxy/2+yinc;
i = (x2-x1+1)*(y2-y1+1)+4;
gfxblk = (RasterBlock *)malloc(i);
if (!gfxblk) {
restext();
printf("ERROR: Allocating memory for gfxblk: %d
bytes\n",i);
exit(1);
}
colr = 1;
for(i=0;i<=maxx/2;i++) {
drwcircle(1,colr,maxx/4+i,maxy/2,maxy/5);
colr+=1;
if(colr>15)
colr = 1;
}
drwbox(1,0,x1,y1,x2,y2);
blkget(x1,y1,x2,y2,gfxblk);
cntx = (x2-x1) / 2 + x1;
cnty = (y2-y1) / 2 + y1;
fillarea(x1+2,y1+2,0,0);
i = blkrotatesize(45,gfxblk);
spritebkgnd = (RasterBlock *)malloc(i);
if (!spritebkgnd) {
restext();
printf("ERROR: Allocating memory for spritebkgnd: %d
bytes\n",i);
exit(1);
}
gfxblk2 = (RasterBlock *)malloc(i);
if (!gfxblk2) {
restext();
printf("ERROR: Allocating memory for gfxblk2: %d
bytes\n",i);
exit(1);
}
blkget(x1,y1,x2,y2,spritebkgnd);
setview(0,64,maxx,maxy);
for(i=0;i<=360;i+=3) {
rot = blkrotate(i,1,gfxblk,gfxblk2);
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
168
spritegap(1,cntx-(gfxblk2->width)/2,cnty-(gfxblk2-
>height)/2,gfxblk2,spritebkgnd);
sdelay(3);
}
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
blkput(SET,x1,y1,(RasterBlock *)gfxblk);
getch();
videomodeset(vmode);
exit(0);
}
169
SPRITEGET
PROTOTYPE
extern void far spriteget (int transcolr, int x, int y,
RasterBlock far *sprite, RasterBlock far *spritebkgnd)
INPUT
transcolr - index to color in current palette
x, y - top, left corner of block
sprite - sprite to use as pattern
OUTPUT
no value returned
spritebkgnd - sprite background
USAGE
SPRITEGET is used in sprite graphics or animation to
retrieve the background for a sprite, normally just before
using SPRITEPUT. Sprite contains the sprite which should
have been previously defined by BLKGET or similar function.
Transcolr is the transparent color assumed in the sprite.
Spritebkgnd, a pointer to a RasterBlock structure the same
size as the sprite, will receive the sprite's background.
The top, left corner of the sprite's location is specified
by x, y.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGAP,
SPRITEPUT
EXAMPLE
/*
* Show spriteget
*/
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, i, j, colr, xinc, yinc, x1, y1, x2, y2, cntx,
cnty, rot;
RasterBlock *gfxblk, *gfxblk2, *spritebkgnd;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
170
if ( whichmem() < 512)
exit(1);
if ( !res640() )
exit(1);
xinc = maxx/20;
yinc = maxy/20;
x1 = maxx/2-xinc;
y1 = maxy/2-yinc;
x2 = maxx/2+xinc;
y2 = maxy/2+yinc;
i = (x2-x1+1)*(y2-y1+1)+4;
gfxblk = (RasterBlock *)malloc(i);
if (!gfxblk) {
restext();
printf("ERROR: Allocating memory for gfxblk: %d
bytes\n",i);
exit(1);
}
colr = 1;
for(i=0;i<=maxx/2;i++) {
drwcircle(1,colr,maxx/4+i,maxy/2,maxy/5);
colr+=1;
if(colr>15)
colr = 1;
}
drwbox(1,0,x1,y1,x2,y2);
blkget(x1,y1,x2,y2,gfxblk);
cntx = (x2-x1) / 2 + x1;
cnty = (y2-y1) / 2 + y1;
fillarea(x1+2,y1+2,0,0);
i = blkrotatesize(45,gfxblk);
spritebkgnd = (RasterBlock *)malloc(i);
if (!spritebkgnd) {
restext();
printf("ERROR: Allocating memory for spritebkgnd: %d
bytes\n",i);
exit(1);
}
gfxblk2 = (RasterBlock *)malloc(i);
if (!gfxblk2) {
restext();
printf("ERROR: Allocating memory for gfxblk2: %d
bytes\n",i);
exit(1);
}
blkget(x1,y1,x2,y2,spritebkgnd);
setview(0,64,maxx,maxy);
for(i=0;i<=360;i+=3) {
rot = blkrotate(i,1,gfxblk,gfxblk2);
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
spriteget(1,cntx-(gfxblk2->width)/2,cnty-(gfxblk2-
>height)/2,gfxblk2,spritebkgnd);
171
spriteput(SET,1,cntx-(gfxblk2->width)/2,cnty-(gfxblk2-
>height)/2,gfxblk2);
sdelay(3);
}
spriteput(SET,1,cntx-(spritebkgnd->width)/2,cnty-
(spritebkgnd->height)/2,spritebkgnd);
blkput(SET,x1,y1,(RasterBlock *)gfxblk);
getch();
videomodeset(vmode);
exit(0);
}
172
SPRITEPUT
PROTOTYPE
extern void far spriteput (PixelMode mode, int transcolr,
int x, int y, RasterBlock far *sprite)
INPUT
mode - pixel write mode
transcolr - index to color in current palette
x, y - top, left corner of block
sprite- sprite to place on screen
OUTPUT
no value returned
USAGE
SPRITEPUT is used in sprite graphics or animation to display
a sprite or, more commonly, its background. Sprite contains
the sprite which should have been previously defined by
BLKGET, SPRITEGAP or SPRITEGET. Transcolr is the
transparent color assumed in sprite. The top, left corner
of the sprite's location is specified by x, y.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGAP,
SPRITEGET
EXAMPLE
See SPRITEGET
173
VIDEOMODEGET
PROTOTYPE
extern int far videomodeget (void)
INPUT
no input parameters
OUTPUT
the current video mode
USAGE
VIDEOMODEGET returns the current video mode. This function
is best used to retrieve the video mode being used when a
program begins. When the program ends, this video mode can
then be restored using VIDEOMODESET.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RES1280, RESTEXT,
VIDEOMODESET
EXAMPLE
/*
* save the current video mode, enable 640x480x256, and
reset the video mode
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
vmode = videomodeget();
if ( !whichvga() )
exit(1);
if ( whichmem() < 512)
exit(1);
res640();
videomodeset(vmode);
printf("we are back!");
getch();
exit(0);
}
174
VIDEOMODESET
PROTOTYPE
extern void far videomodeset (int videomode)
INPUT
mode - number of video mode
OUTPUT
no value returned
USAGE
VIDEOMODESET sets the video mode specified by mode. This
function is best used at the end of a program to restore the
video mode to the mode in use when the program began. The
program should retrieve the video mode at the beginning by
using VIDEOMODEGET.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RES1280, RESTEXT,
VIDEOMODEGET
EXAMPLE
See VIDEMODEGET
175
VIDEOOFF
PROTOTYPE
extern void far videooff (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
VIDEOOFF turns the output display off. Graphics may still
be drawn to the screen. However, the computer's monitor
will display nothing and appear black. This function can be
used to hide graphics being drawn by initially using
VIDEOOFF and then later calling VIDEOON.
SEE ALSO
VIDEOON
EXAMPLE
/*
* disable the video for about 3 seconds, then enable it
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
printf("press a key to disable video for 3 seconds...");
getch();
videooff();
sdelay(195);
videoon();
videomodeset(vmode);
printf("we are back!");
getch();
exit(0);
}
176
VIDEOON
PROTOTYPE
extern void far videoon (void)
INPUT
no input parameters
OUTPUT
no value returned
USAGE
VIDEOON turns the display on. All graphics that were drawn
while the display was off are now visible. This function
can be used to hide graphics being drawn by initially using
VIDEOOFF and then later calling VIDEOON.
SEE ALSO
VIDEOOFF
EXAMPLE
See VIDEOOFF
177
WHICHCPU
PROTOTYPE
extern int far whichcpu (void)
INPUT
no input parameters
OUTPUT
processor type
USAGE
WHICHCPU returns the computer's processor type as 86, 286,
386 or 486. This function should be called by any program
using this library's routines to insure that the computer is
at least 386 compatible or better.
SEE ALSO
WHICHJOYSTICK, WHICHMOUSE, WHICHVGA
EXAMPLE
/*
* id the microprocessor
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode;
int cpu;
cpu = whichcpu();
printf("Microprocessor is identified as an 80%d.\n",
cpu);
getch();
exit(0);
}
178
WHICHJOYSTICK
PROTOTYPE
extern int far whichjoystick (void)
INPUT
no input parameters
OUTPUT
available joystick support
USAGE
WHICHJOYSTICK returns the joystick support available on the
computer. This function should be called prior to use of
the joysticks to verify that joysticks are available. If
the function returns a -1, there is no joystick port present
or no BIOS support for a joystick. Joystick A is bit 1 and
B is bit 2. Therefore, a return value of 1 means joystick A
is available, a value of 2 means B is available and a value
of 3 means both are available. If no bits are set, there
are no joysticks present.
SEE ALSO
JOYSTICKINFO, WHICHCPU, WHICHMOUSE, WHICHVGA
EXAMPLE
/* id any joysticks */
#include <stdlib.h>
#include "svgacc.h"
void main(void)
{
int vmode, joystick;
joystick = whichjoystick();
switch (joystick) {
case -1:
printf("No joystick port detected or no joystick
BIOS support present.\n\n");
break;
case 0:
printf("No joystick detected\n\n");
break;
case 1:
printf("Joystick A is present and available.\n\n");
break;
case 2:
printf("Joystick B is present and available.\n\n");
179
break;
case 3:
printf("Both Joystick A and Joystick B are
present.\n\n");
break;
}
}
180
WHICHMEM
PROTOTYPE
extern int far whichmem (void)
INPUT
no input parameters
OUTPUT
installed video memory in kilobytes
USAGE
WHICHMEM returns the amount of installed video memory as
previously determined by WHICHVGA. WHICHVGA should be
called prior to WHICHMEM. This function should be called
prior to any of the RES### functions to verify that there is
enough memory to support the desired resolution. If SETCARD
was used to set the video card and memory, WHICHMEM will
return the amount of memory as defined by SETCARD.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RES1280, SETCARD,
WHICHVGA
EXAMPLE
/*
* id the video memory
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int vmode, vga, mem;
vga = whichvga();
mem = whichmem();
printf("Installed video memory is %d k.\n", mem);
getch();
exit(0);
}
181
WHICHMOUSE
PROTOTYPE
extern int far whichmouse (void)
INPUT
no input parameters
OUTPUT
number of buttons on mouse
USAGE
WHICHMOUSE returns a value indicating whether a Microsoft
compatible mouse is available. If the function returns a 0,
no mouse is available. A non zero value indicates a mouse
and Microsoft compatible driver are installed and gives the
number of buttons (2 or 3) available.
SEE ALSO
MOUSEINFO, WHICHCPU, WHICHJOYSTICK, WHICHVGA
EXAMPLE
See MOUSEINFO
182
WHICHVGA
PROTOTYPE
extern VGAChipset far whichvga (void)
INPUT
no input parameters
OUTPUT
WHICHVGA returns a code identifying the video card.
USAGE
WHICHVGA identifies the video card installed and the amount
of video memory. In addition this function sets up the
default font and mouse cursor. This function must be called
before any other graphics function. The code returned
identifies the video card according to the following table:
1 Acumos AVGA2/3 SuperVGA
2 ATI Technologies 18/28/38/68800
SuperVGA
3 Ahead V5000 ver A SuperVGA
4 Ahead V5000 ver B SuperVGA
5 Chips and Technologies 82C45x SuperVGA
6 Cirrus Logic CL-GD 5xx, 6xx, 28xx,
54xx, 62xx SuperVGA
7 Everex Micro Enhancer Ev236/6xx
SuperVGA
8 Genoa 61/62/63/64/6600 SuperVGA
9 NCR 77C21/22/22E/22E+ SuperVGA
10 Oak Technologies OTI-037C/067/077/087
SuperVGA
11 Paradise/Western Digital PVGA1A,
WD90C00/1x/2x/3x SuperVGA
12 Realtek RT3106 SuperVGA
13 Trident 8800CS, 8900B/C/CL/CX, 90x0
SuperVGA
14 Tseng Labs ET3000-AX/BX/BP SuperVGA
15 Tseng Labs ET4000/W32/W32I SuperVGA
16 VESA compatible SuperVGA
17 Video 7 HT-208/16 SuperVGA
18 Avance Logic AL2101 SuperVGA
19 MXIC MX68000/10 SuperVGA
20 Primus P2000 SuperVGA
Any value returned not found on this table represents an
unidentified video card.
No graphics functions should be called unless the video card
is properly identified.
183
SEE ALSO
SETCARD, WHICHCPU, WHICHJOYSTICK, WHICHMOUSE, WHICHMEM
EXAMPLE
/*
* id the svga
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
char buf[40];
switch(whichvga()) {
case ACUMOS:
sprintf(buf,"Acumos AVGA2/3 SuperVGA");
break;
case ATI:
sprintf(buf,"ATI Technologies 18/28/38/68800
SuperVGA");
break;
case AHEADA:
sprintf(buf,"Ahead V5000 Ver A SuperVGA");
break;
case AHEADB:
sprintf(buf,"Ahead V5000 Ver B SuperVGA");
break;
case CHIPSTECH:
sprintf(buf,"Chips and Technologies 82C450/1/2/3/5/6/7
SuperVGA");
break;
case CIRRUS:
sprintf(buf,"Cirrus Logic CL-GD 5xx,6xx,28xx,54xx,62xx
SuperVGA");
break;
case EVEREX:
sprintf(buf,"Everex EV236/6xx Micro Enhancer
SuperVGA");
break;
case GENOA:
sprintf(buf,"Genoa 61/62/63/64/6600 SuperVGA");
break;
case NCR:
sprintf(buf,"NCR 77C21/22/22E/22E+ SuperVGA");
break;
case OAKTECH:
184
sprintf(buf,"Oak Technologies OTI-037/67/77/87C
SuperVGA");
break;
case PARADISE:
sprintf(buf,"Paradise/Western Digital
PVGA1A,WD90C00/1x/2x/3x SuperVGA");
break;
case REALTEK:
sprintf(buf,"Realtek RT3106 SuperVGA");
break;
case TRIDENT:
sprintf(buf,"Trident 8800CS,8900B/C/CL/CX,90x0
SuperVGA");
break;
case TSENG3:
sprintf(buf,"Tseng Labs ET3000-AX/BX/BP SuperVGA");
break;
case TSENG4:
sprintf(buf,"Tseng Labs ET4000/W32/W32I SuperVGA");
break;
case VESA:
sprintf(buf,"VESA compatible SuperVGA");
break;
case VIDEO7:
sprintf(buf,"Video 7 HT-208/16 SuperVGA");
break;
case AVANCE:
sprintf(buf,"Avance Logic AL2101 SuperVGA");
break;
case MXIC:
sprintf(buf,"MXIC MX68000/10 SuperVGA");
break;
case PRIMUS:
sprintf(buf,"Primus P2000 SuperVGA");
break;
default:
printf("Sorry, unable to identify video card or it is
not a SuperVGA video adapter.\n");
exit(0);
}
printf("Video card/chip is identified as %s.\n",&buf);
exit(0);
}
185
WHICHXMS
PROTOTYPE
extern int far whichxms (unsigned int far *xmskbytesavail,
unsigned int far *xmshandlesavail)
INPUT
no input parameters
OUTPUT
WHICHXMS returns a 1 if extended memory support is detected,
0 otherwise.
xmskbytesavail - number of free kilobytes in extended memory
xmshandlesavail - number of available free handles
USAGE
WHICHXMS detects the existence of extended memory support
and sets up the library function calls. This function must
be called before any other extended memory functions.
WHICHXMS also returns the number of free kilobytes of
extended memory and the number of available handles. The
number of available handles is limited, normally to 32.
This limit can be modified by changing the extended memory
driver (Microsoft's HIMEM.SYS is the most common) command
line in the CONFIG.SYS file.
SEE ALSO
XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
/*
* show what xms memory is available
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int er, mem, handles;
if ( whichxms(&mem,&handles) ) {
printf("an active xms memory manager was found!\n");
printf("a total of %d kb of xms memory
available...\n",mem);
printf("a total of %d xms memory handles
available...\n",handles);
186
printf(" \n");
if ((mem < 1) || (handles < 1)) {
printf("sorry...there is either no free xms or\n");
printf("no free handles\n");
printf(" \n");
printf("xms support not available...\n");
exit(1);
}
else {
printf(" \n");
printf("xms support is ready and available!\n");
exit(1);
}
}
else {
printf("sorry...no active xms memory manager
found...\n");
printf("make sure you have an xms memory manager\n");
printf("(such as HIMEM.SYS) loaded\n");
printf(" \n");
printf("xms support not available...\n");
exit(1);
}
exit(0);
}
187
XMSALLOCATE
PROTOTYPE
extern int far xmsallocate (unsigned int reqkbytes)
INPUT
reqkbytes - requested number of kilobytes of extended memory
OUTPUT
XMSALLOCATE returns the assigned memory handle if the
allocation is successful, 0 otherwise.
USAGE
XMSALLOCATE attempts to allocate the requested number of
kilobytes in extended memory. If successful, the function
returns the handle of the new memory block. If the function
returns zero, then the allocation was unsuccessful; check
XMSERROR for error codes.
All allocated blocks must be freed using XMSFREE before a
program terminates or the memory is lost until the machine
is rebooted. Simply exiting a program will not free
allocated extended memory blocks.
SEE ALSO
WHICHXMS, XMSCOPY, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
188
XMSCOPY
PROTOTYPE
extern int far xmscopy (int xmssrchandle, long srcoffset,
int xmsdesthandle, long destoffset, unsigned long count)
INPUT
xmssrchandle - handle of source extended memory block
srcoffset - number of bytes from beginning of source memory
block
xmsdesthandle - handle of destination extended memory block
destoffset - number of bytes from beginning of destination
memory block
count - number of bytes to copy from source to destination
(must be even)
OUTPUT
XMSCOPY returns a 1 if copy was successful, 0 otherwise.
USAGE
XMSCOPY copies the number of bytes specified in count from
the source extended memory block to the destination extended
memory block. Count must be an even number. The copy may
begin and/or end offset from the beginning of the source and
destination blocks by passing non zero values in srcoffset
and/or destoffset. The copy will occur faster if both
offsets are divisible by four. If the copy was
unsuccessful, check XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
/*
* show xms functions: this will copy one array into one
* xms block, copy that xms block to a second xms block,
* and then copy that second xms block to another array
*/
#include <stdlib.h>
#include <conio.h>
#include "svgacc.h"
void main(void)
{
int i, handle1, handle2, er, mem, handles;
int test1[10], test2[10];
189
/* make sure xms is ready and available */
if ( whichxms(&mem,&handles) ) {
if ((mem < 1) || (handles < 1)) {
printf("sorry...there is either no free xms or\n");
printf("no free handles\n");
exit(1);
}
}
else {
printf("sorry...no active xms memory manager
found...\n");
printf("make sure you have an xms memory manager\n");
printf("(such as HIMEM.SYS) loaded\n");
exit(1);
}
/* generate some data */
for(i=0;i<10;i++)
{
test1[i] = i;
}
/* allocate the first xms block */
handle1 = xmsallocate(1);
if ( !handle1 ) {
printf("opps there is some error...unable to allocate
xms...\n");
printf("error # %d\n",xmserror());
er = xmsfree(handle1);
exit(1);
}
/* allocate the second xms block */
handle2 = xmsallocate(1);
if ( !handle2 ) {
printf("opps there is some error...unable to allocate
xms...\n");
printf("error # %d\n",xmserror());
er = xmsfree(handle1);
er = xmsfree(handle2);
exit(1);
}
/* copy our source array into first xms block */
er = xmsput (test1, handle1, 0, sizeof(test1));
if ( !er ) {
printf("opps there is some error...see error code
list...\n");
printf("error # %d\n",xmserror());
er = xmsfree(handle1);
er = xmsfree(handle2);
exit(1);
}
190
/* copy first xms block into second xms block */
er = xmscopy (handle1, 0, handle2, 0, sizeof(test1));
if ( !er ) {
printf("opps there is some error...see error code
list...\n");
printf("error # %d\n",xmserror());
er = xmsfree(handle1);
er = xmsfree(handle2);
exit(1);
}
/* copy second xms block to out destination array */
er = xmsget (handle2, 0, test2, sizeof(test1));
if ( !er ) {
printf("opps there is some error...see error code
list...\n");
printf("error # %d\n",xmserror());
er = xmsfree(handle1);
er = xmsfree(handle2);
exit(1);
}
/* free up all the xms memory we have allocated */
er = xmsfree(handle1);
er = xmsfree(handle2);
/* show the results */
printf("ok...we initialized one array with data, copied
that\n");
printf("array to an xms block, copied that xms block to
a\n");
printf("second xms block, and finally copied the second
xms\n");
printf("block into a new array...here are the
results:\n");
printf(" \n");
printf("source array destination array\n");
for(i=0;i<10;i++)
{
printf(" %d %d\n",test1[i],test2[i]);
}
exit(0);
}
191
XMSERROR
PROTOTYPE
extern int far xmserror (void)
INPUT
no input parameters
OUTPUT
XMSERROR returns the error code from the most recent XMS
function call.
USAGE
XMSERROR returns the error code from the most recent XMS
function call. Each XMS function resets the error code to
zero. Therefore, if there has been an error, the error code
should be checked immediately. The error code will be one
of the following:
0 no error
1 WHICHXMS has not been
called
2 number of bytes to
copy is zero
3 number of bytes to
copy is odd
4 offset into XMS block
is zero
128 Function not
implemented
129 VDISK device driver
was detected
142 General driver error
143 Unrecoverable driver
error
146 DX is less than
/HMAMIN= parameter
160 All extended memory is
allocated
161 XMM handles are
exhausted
162 Handle is invalid
163 Source handle is
invalid
164 Source offset is
invalid
165 Destination handle is
invalid
166 Destination offset is
invalid
192
167 Length is invalid
168 Overlap in move
request is invalid
169 Parity error detected
171 Block locked
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSFREE, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
193
XMSFREE
PROTOTYPE
extern int far xmsfree (int xmshandle)
INPUT
xmshandle - handle of extended memory block to free
OUTPUT
XMSFREE returns 1 if extended memory block was deallocated,
0 otherwise.
USAGE
XMSFREE deallocates the specified extended memory block.
All allocated blocks must be freed before a program
terminates or the memory is lost until the machine is
rebooted. Simply exiting a program will not free allocated
extended memory blocks. If the function was unsuccessful,
check XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
194
XMSGET
PROTOTYPE
extern int far xmsget (int xmshandle, long offset, void far
*destmem, unsigned long count)
INPUT
xmshandle - handle of source extended memory block
offset - number of bytes from beginning of source memory
block
count - number of bytes to copy from extended memory to
conventional memory (must be even)
OUTPUT
XMSGET returns 1 if the copy was successful, 0 otherwise.
destmem - copy of data in conventional memory
USAGE
XMSGET retrieves data from extended memory and places it in
conventional memory. The number of bytes copied must be an
even number and cannot be larger than 65536. The copy may
begin off the beginning of the source extended memory block
by specifying an non zero offset. If the function was
unsuccessful, check XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSPUT
EXAMPLE
See XMSCOPY
195
XMSPUT
PROTOTYPE
extern int far xmsput (void far *sourcemem, int xmshandle,
long offset, unsigned long count)
INPUT
sourcemem - source data in conventional memory
xmshandle - handle of destination extended memory block
offset - number of bytes from beginning of destination
memory block
count - number of bytes to copy from conventional memory to
extended memory (must be even)
OUTPUT
XMSPUT returns 1 if the copy was successful, 0 otherwise.
USAGE
XMSPUT copies data from conventional memory to extended
memory. The number of bytes copied must be an even number
and cannot be larger than 65536. The destination may begin
off the beginning of the extended memory block by specifying
an non zero offset. If the function was unsuccessful, check
XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSGET
EXAMPLE
See XMSCOPY
196
APPENDIX A. SVGACC.H
This is the header file containing function prototypes and
structure definitions for SVGACC.LIB. This file should be
included in every program module that uses this library. To
properly include the header file, place the following line at
the top of the every code module:
#include "svgacc.h"
Without these prototypes and definitions, the C/C++ compiler
will be unable to compile any code module using the commands
found in this library.
/* SVGACC Include File for MS C/C++/QuickC and Borland C/C++
* Copyright 1994 by Stephen L. Balkum and Daniel A. Sill
* Zephyr Software P.O. Box 7704, Austin, Texas 78713-7704
*/
#ifndef SVGACC_H
#define SVGACC_H
typedef unsigned char byte;
typedef struct {
char r;
char g;
char b;
} RGB;
typedef RGB PaletteData[256];
typedef struct {
byte hotspotx;
byte hotspoty;
byte data[384];
} MouseCursor;
typedef struct {
byte width;
byte height;
byte data[4096];
} Font;
typedef enum {
NO_ACTION = 0,
SET,
XOR,
OR,
AND
} PixelMode;
typedef enum {
UNKNOWN = 0,
197
ACUMOS,
ATI,
AHEADA,
AHEADB,
CHIPSTECH,
CIRRUS,
EVEREX,
GENOA,
NCR,
OAKTECH,
PARADISE,
REALTEK,
TRIDENT,
TSENG3,
TSENG4,
VESA,
VIDEO7,
AVANCE,
MXIC,
PRIMUS
} VGAChipset;
typedef struct {
unsigned int width;
unsigned int height;
byte data[1];
} RasterBlock;
typedef struct {
int x;
int y;
} D2Point;
typedef struct {
int x;
int y;
int z;
} D3Point;
typedef struct {
int eyex;
int eyey;
int eyez;
int scrd;
int theta;
int phi;
} ProjParameters;
#ifdef __cplusplus
extern "C" {
#endif
/* Global variables */
extern const int far maxx;
198
extern const int far maxy;
extern const int far viewx1;
extern const int far viewy1;
extern const int far viewx2;
extern const int far viewy2;
/* 'BLocK' methods to manipulate RasterBlocks on and off the
screen */
extern int far blkget (int x1, int y1, int x2, int y2,
RasterBlock far *gfxblk);
extern void far blkput (PixelMode mode, int x, int y,
RasterBlock far *gfxblk);
extern void far blkresize (unsigned newxsize, unsigned
newysize, RasterBlock far *sourcegfxblk, RasterBlock far
*destgfxblk);
extern int far blkrotate (int ang, int backfill,
RasterBlock far *sourcegfxblk, RasterBlock far
*destgfxblk);
extern int far blkrotatesize (int ang, RasterBlock far
*sourcegfxblk);
/* 'BYTECOPY' method for fast memory copy */
extern void far bytecopy (void far *src, void far *dst,
unsigned long numbytes);
/* '2D' methods to transform D2Points */
extern void far d2rotate (int points, int xorigin, int
yorigin, int ang, D2Point far *inary, D2Point far
*outary);
extern void far d2scale (int points, int xscale, int yscale,
D2Point far *inary, D2Point far *outary);
extern void far d2translate (int points, int xtrans, int
ytrans, D2Point far *inary, D2Point far *outary);
/* '3D' methods to transform D3Points */
extern int far d3project (int points, ProjParameters far
*params, D3Point far *inary, D2Point far *outary);
extern void far d3rotate (int points, int xorigin, int
yorigin, int zorigin, int zrang, int yrang, int xrang,
D3Point far *inary, D3Point far *outary);
extern void far d3scale (int points, int xscale, int yscale,
int zscale, D3Point far *inary, D3Point far *outary);
extern void far d3translate (int points, int xtrans, int
ytrans, int ztrans, D3Point far *inary, D3Point far
*outary);
/* 'DRaW' methods for placing text and graphics primitives
on screen */
199
extern void far drwbox (PixelMode mode, int colr, int x1,
int y1, int x2, int y2);
extern void far drwcircle (PixelMode mode, int colr, int
centerx, int centery, int radius);
extern void far drwellipse (PixelMode mode, int colr, int
centerx, int centery, int radiusx, int radiusy);
extern void far drwfillbox (PixelMode mode, int colr, int
x1, int y1, int x2, int y2);
extern void far drwfillcircle (PixelMode mode, int colr, int
centerx, int centery, int radius);
extern void far drwfillellipse (PixelMode mode, int colr,
int centerx, int centery, int radiusx, int radiusy);
extern void far drwline (PixelMode mode, int colr, int x1,
int y1, int x2, int y2);
extern void far drwpoint (PixelMode mode, int colr, int x,
int y);
extern void far drwstring (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y);
extern void far drwstringdn (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y);
extern void far drwstringlt (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y);
extern void far drwstringrt (PixelMode mode, int fcolr, int
bcolr, const char far *strng, int x, int y);
/* 'FILL' methods for filling various regions on screen with
a color */
extern void far fillarea (int xseed, int yseed, int
bordercolr, int fillcolr);
extern void far fillconvexpoly (int colr, int points,
D2Point far *inary);
extern void far fillcolor (int xseed, int yseed, int
oldcolr, int newcolr);
extern void far fillpage (int colr);
extern void far fillscreen (int colr);
extern void far fillview (int colr);
/* 'FONT' methods for setting the current font */
extern void far fontgetinfo (int far *wdth, int far *hght);
extern void far fontset (Font far *font);
extern void far fontsystem (void);
/* 'GET' methods to return information held by library */
extern void far getlaststring (RasterBlock far
*strnggfxblk);
extern long far getarccos (long cosvalue);
extern long far getarcsin (long sinvalue);
extern long far getarctan (long tanvalue);
extern long far getcos (long angle);
extern int far getpoint (int x, int y);
extern long far getsin (long angle);
200
extern long far gettan (long angle);
/* 'GIF' methods to read / write GIF files and place images
on screen */
extern int far gifgetinfo (const char far *name, int far
*gifxsize, int far *gifysize, int far *numcolors, RGB far
*pal);
extern int far gifmake (int x1, int y1, int x2, int y2,
const char far *name);
extern int far gifput (PixelMode mode, int xloc, int yloc,
const char far *name);
/* 'JOYSTICK' method to read joysticks' status */
extern void far joystickinfo (int far *jax, int far *jay,
int far *jabuts, int far *jbx, int far *jby, int far
*jbbuts);
/* 'MOUSE' methods to interact with mouse driver */
extern void far mousebutpress (int reqbut, int far *xloc,
int far *yloc, int far *num, int far *mbuts);
extern void far mousebutrelease (int reqbut, int far *xloc,
int far *yloc, int far *num, int far *mbuts);
extern void far mousecursordefault (void);
extern void far mousecursorset (MouseCursor far
*mousecursor);
extern void far mouseenter (void);
extern void far mouseexit (void);
extern void far mousehide (void);
extern void far mouseinfo (int far *drvmajorver, int far
*drvminorver, int far *mousetype, int far *irqnumber);
extern void far mouselocset (int xloc, int yloc);
extern void far mouserangeset (int x1, int y1, int x2, int
y2);
extern void far mouserestorestate (byte far *mousebuf);
extern void far mousesavestate (byte far *mousebuf);
extern void far mousesensset (int xsens, int ysens, int
dblspdthresh);
extern void far mouseshow (void);
extern void far mousestatus (int far *x, int far *y, int far
*mbuts);
extern int far mousestoragesize (void);
extern void far overscanset (int colr);
/* 'PAGE' methods to control paging abilities */
extern int far pageactive (int page);
extern int far pagedisplay (int x, int y, int page);
/* 'PALette' methods to manipulate and activate palettes */
201
extern void far palchgauto (RGB far *pal, RGB far *newpal,
int firstcolr, int lastcolr, int speed);
extern void far palchgstep (RGB far *pal, RGB far *newpal,
int firstcolr, int lastcolr, int percent);
extern void far palcopy (RGB far *srcpal, RGB far *destpal,
int firstcolr, int lastcolr);
extern void far paldimstep (RGB far *pal, int firstcolr, int
lastcolr, int percent);
extern void far palget (RGB far *pal, int firstcolr, int
lastcolr);
extern void far palioauto (RGB far *pal, int firstcolr, int
lastcolr, int speed);
extern void far palrotate (RGB far *pal, int firstcolr, int
lastcolr, int shift);
extern void far palset (RGB far *pal, int firstcolr, int
lastcolr);
/* 'RESolution' methods to set various video modes */
extern int far res320 (void);
extern int far res640 (void);
extern int far res640l (void);
extern int far res800 (void);
extern int far res1024 (void);
extern int far res1280 (void);
extern int far restext (void);
/* 'SCROLL' methods for scrolling various sections of the
screen */
extern void far scrolldn (int x1, int y1, int x2, int y2,
int num, int colr);
extern void far scrolllt (int x1, int y1, int x2, int y2,
int num, int colr);
extern void far scrollrt (int x1, int y1, int x2, int y2,
int num, int colr);
extern void far scrollup (int x1, int y1, int x2, int y2,
int num, int colr);
/* 'Sync' DELAY method */
extern void far sdelay (int count);
/* 'SET' methods to adjust library internal variables */
extern void far setcard (VGAChipset chip, int mem);
extern void far setview (int x1, int y1, int x2, int y2);
/* 'SPRITE' methods for manipulating sprites on and off
screen */
extern int far spritecolldetect (int transcolr, int x1, int
y1, int x2, int y2, RasterBlock far *sprite1, RasterBlock
far *sprite2);
202
extern void far spritegap (int transcolr, int x, int y,
RasterBlock far *sprite, RasterBlock far *spritebkgnd);
extern void far spriteget (int transcolr, int x, int y,
RasterBlock far *sprite, RasterBlock far *spritebkgnd);
extern void far spriteput (PixelMode mode, int transcolr,
int x, int y, RasterBlock far *sprite);
/* 'VIDEO' methods to interact with video mode and display
*/
extern int far videomodeget (void);
extern void far videomodeset (int videomode);
extern void far videooff (void);
extern void far videoon (void);
/* 'Identification' methods to discover WHICH hardware is
available */
extern int far whichcpu (void);
extern int far whichjoystick (void);
extern int far whichmem (void);
extern int far whichmouse (void);
extern VGAChipset far whichvga (void);
extern int far whichxms (unsigned int far *xmskbytesavail,
unsigned int far *xmshandlesavail);
/* 'XMS' methods to store and retrieve extended memory */
extern int far xmsallocate (unsigned int reqkbytes);
extern int far xmscopy (int xmssrchandle, long srcoffset,
int xmsdesthandle, long destoffset, unsigned long count);
extern int far xmserror (void);
extern int far xmsfree (int xmshandle);
extern int far xmsget (int xmshandle, long offset, void far
*destmem, unsigned long count);
extern int far xmsput (void far *sourcemem, int xmshandle,
long offset, unsigned long count);
#ifdef __cplusplus
}
#endif
#endif
/* SVGACC_H */
203
APPENDIX B. JOYSTICK PORTS AND Y-CABLES
SCHEMATIC WIRING DIAGRAM FOR A STANDARD JOYSTICK PORT
DB15 male
connector
Joystick B ___ Joystick A
__/ |
/ o | 1 -------------------+
+------------------ 9 | o | ___Button A |
| Button A___ | o | 2 --o o-+ |
| +-o o-- 10 | o | | X Axis |
| X Axis | | o | 3 -------------+ |
| +------------ 11 | o | | | |
| | | | o | 4 ------+ | |
+--/\/\/\ +------ 12 | o | | /\/\/\--+
| | | o | 5 | |
| +------------ 13 | o | | |
| | | ___ | o | 6 -------------+ |
| | +-o o-- 14 | o | ___ | | |
| | Button B | o | 7 --o o-+ | |
| | 15 | o | Button B /\/\/\--+
+--/\/\/\ \__ o | 8 Y Axis
Y Axis \___|
Notes:
1) This diagram comes with NO warranties expressed or implied.
It is provided for information only. In no event shall
Stephen L. Balkum, Daniel A. Sill or Zephyr Software be held
liable for damages resulting from use, misuse, or inability
to use this information.
2) The x and y axis potentiometers have a typical range of 0 to
100k ohms. Buttons are normally open and close when
pressed.
3) This diagram is correct for joystick ports that conform to
the standard set forth by IBM. Some specialty joystick cards
provide separate A and B joystick connectors. For these
cards, both connectors are wired to pins 1 through 8 as
shown in the diagram.
4) Many 'Super I/O' boards (2H/2F/2S/1P/1G) equipped with a
joystick port will support only one joystick. On these
cards, pins 9 through 15 are not used.
5) Commercially available joysticks are wired to use pins 1
through 8 and, therefore, will always be 'Joystick A' if
plugged directly into a dual joystick port connector.
6) Many sound cards provide joystick ports; however, their
connector wiring does not always conform to the standard
shown above. Some of these connectors may be used for other
204
purposes such as a MIDI port. See the documentation that
comes with the sound card.
7) If there is more than one joystick port on a computer
configured to operate the same joystick, only ONE port
should be enabled at any given time for proper operation.
Disable all but one joystick port. For example, if the
computer has both a Super I/O card and a sound card, the
joystick port on the Super I/O card should be disabled since
the sound card's port probably supports two joysticks and
the I/O card supports only one.
205
SCHEMATIC WIRING DIAGRAM FOR A JOYSTICK Y-CABLE
___
DB15 male __/ |
connector to / o | 1 --------+
Joystick Port 9 | o | |
on computer | o | 2 --------|-+
+-------- 10 | o | | |
| | o | 3 --------|-|-+
| +------ 11 | o | | | |
| | | o | 4 --------|-|-|-+
| | 12 | o | | | | |
| | | o | 5 | | | |
| | +---- 13 | o | | | | |
| | | | o | 6 --------|-|-|-|-+
| | | +-- 14 | o | | | | | |
| | | | | o | 7 --------|-|-|-|-|-+
| | | | 15 | o | | | | | | |
| | | | \__ o | 8 | | | | | |
| | | | \___| | | | | | |
| | | | | | | | | |
| | | | | | | | | |
| | | | +-----------------------+ | | | | |
| | | | | | | | | | |
| | | | | +---------------------|-|-|-+ | |
| | | | | | | | | | | |
| | | | | | | | | | | |
DB15 female | | | | | | DB15 female | | | | | |
connector to | | | | | | connector to | | | | | |
Joystick B | | | | | | Joystick A | | | | | |
___ | | | | | | ___ | | | | | |
__/ | | | | | | | __/ | | | | | | |
/ o | 1 ---|-|-|-|--+ | / o | 1 --+ | | | | |
9 | o | | | | | | 9 | o | | | | | |
| o | 2 ---+ | | | | | o | 2 ----+ | | | |
10 | o | | | | | 10 | o | | | | |
| o | 3 -----+ | | | | o | 3 ------+ | | |
11 | o | | | | 11 | o | | | |
| o | 4 -------|-|----+ | o | 4 --------+ | |
12 | o | | | 12 | o | | |
| o | 5 | | | o | 5 | |
13 | o | | | 13 | o | | |
| o | 6 -------+ | | o | 6 ----------+ |
14 | o | | 14 | o | |
| o | 7 ---------+ | o | 7 ------------+
15 | o | 15 | o |
\__ o | 8 \__ o | 8
\___| \___|
Notes:
1) This diagram comes with NO warranties expressed or implied.
It is provided for information only. In no event shall
Stephen L. Balkum, Daniel A. Sill or Zephyr Software be held
206
liable for damages resulting from use, misuse, or inability
to use this information.
2) This cable has worked with a standard joystick port
connector, a Sound Blaster port connector, and a Sound
Blaster Pro joystick port connector.
207